/*
 *
 *    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 "MTRAttributeCacheContainer_Internal.h"
#import "MTRBaseClusters_internal.h"
#import "MTRBaseDevice.h"
#import "MTRBaseDevice_Internal.h"
#import "MTRCallbackBridge_internal.h"
#import "MTRCluster_internal.h"
#import "MTRCommandPayloadsObjc.h"
#import "MTRStructsObjc.h"

#include <controller/TypedReadCallback.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 endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue
{
    if (self = [super initWithQueue:queue]) {
        if (device == nil) {
            return nil;
        }

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

- (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeIdentifyTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeIdentifyTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeIdentifyTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeIdentifyTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(IdentifyGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(IdentifyAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, IdentifyAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, IdentifyAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::AttributeList::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIdentifyAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(IdentifyAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::IdentifyCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterIdentify (Deprecated)

- (void)identifyWithParams:(MTRIdentifyClusterIdentifyParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self identifyWithParams:params completion:completionHandler];
}
- (void)triggerEffectWithParams:(MTRIdentifyClusterTriggerEffectParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self triggerEffectWithParams:params completion:completionHandler];
}

- (void)readAttributeIdentifyTimeWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTimeWithCompletion:completionHandler];
}
- (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIdentifyTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIdentifyTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeIdentifyTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeIdentifyTimeWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeIdentifyTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTimeWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeIdentifyTypeWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeIdentifyTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeIdentifyTypeWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeIdentifyTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIdentifyTypeWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterGroups

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRGroupsClusterAddGroupResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterAddGroupResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsClusterViewGroupResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterViewGroupResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupsClusterGetGroupMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsClusterRemoveGroupResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsClusterRemoveGroupResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Groups::Commands::RemoveAllGroups::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(GroupsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, GroupsAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::AttributeList::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(GroupsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::GroupsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGroups (Deprecated)

- (void)addGroupWithParams:(MTRGroupsClusterAddGroupParams *)params
         completionHandler:
             (void (^)(MTRGroupsClusterAddGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addGroupWithParams:params completion:completionHandler];
}
- (void)viewGroupWithParams:(MTRGroupsClusterViewGroupParams *)params
          completionHandler:
              (void (^)(MTRGroupsClusterViewGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self viewGroupWithParams:params completion:completionHandler];
}
- (void)getGroupMembershipWithParams:(MTRGroupsClusterGetGroupMembershipParams *)params
                   completionHandler:(void (^)(MTRGroupsClusterGetGroupMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self getGroupMembershipWithParams:params completion:completionHandler];
}
- (void)removeGroupWithParams:(MTRGroupsClusterRemoveGroupParams *)params
            completionHandler:
                (void (^)(MTRGroupsClusterRemoveGroupResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self removeGroupWithParams:params completion:completionHandler];
}
- (void)removeAllGroupsWithParams:(MTRGroupsClusterRemoveAllGroupsParams * _Nullable)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self removeAllGroupsWithParams:params completion:completionHandler];
}
- (void)removeAllGroupsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self removeAllGroupsWithParams:nil completion:completionHandler];
}
- (void)addGroupIfIdentifyingWithParams:(MTRGroupsClusterAddGroupIfIdentifyingParams *)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self addGroupIfIdentifyingWithParams:params completion:completionHandler];
}

- (void)readAttributeNameSupportWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNameSupportWithCompletion:completionHandler];
}
- (void)subscribeAttributeNameSupportWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNameSupportWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNameSupportWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterScenes

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRScenesClusterAddSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterAddSceneResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterViewSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterViewSceneResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterRemoveSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterRemoveSceneResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterRemoveAllScenesResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesClusterRemoveAllScenesResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterStoreSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterStoreSceneResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
                }
            }

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterGetSceneMembershipResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesClusterGetSceneMembershipResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesClusterEnhancedAddSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesClusterEnhancedViewSceneResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesClusterCopySceneResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesClusterCopySceneResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeSceneCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSceneCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentSceneWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentSceneWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentGroupWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentGroupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSceneValidWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSceneValidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNameSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastConfiguredByWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLastConfiguredByWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ScenesGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ScenesAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ScenesAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRScenesAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::AttributeList::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRScenesAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRScenesAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ScenesAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ScenesCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterScenes (Deprecated)

- (void)addSceneWithParams:(MTRScenesClusterAddSceneParams *)params
         completionHandler:
             (void (^)(MTRScenesClusterAddSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self addSceneWithParams:params completion:completionHandler];
}
- (void)viewSceneWithParams:(MTRScenesClusterViewSceneParams *)params
          completionHandler:
              (void (^)(MTRScenesClusterViewSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self viewSceneWithParams:params completion:completionHandler];
}
- (void)removeSceneWithParams:(MTRScenesClusterRemoveSceneParams *)params
            completionHandler:
                (void (^)(MTRScenesClusterRemoveSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self removeSceneWithParams:params completion:completionHandler];
}
- (void)removeAllScenesWithParams:(MTRScenesClusterRemoveAllScenesParams *)params
                completionHandler:(void (^)(MTRScenesClusterRemoveAllScenesResponseParams * _Nullable data,
                                      NSError * _Nullable error))completionHandler
{
    [self removeAllScenesWithParams:params completion:completionHandler];
}
- (void)storeSceneWithParams:(MTRScenesClusterStoreSceneParams *)params
           completionHandler:
               (void (^)(MTRScenesClusterStoreSceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self storeSceneWithParams:params completion:completionHandler];
}
- (void)recallSceneWithParams:(MTRScenesClusterRecallSceneParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self recallSceneWithParams:params completion:completionHandler];
}
- (void)getSceneMembershipWithParams:(MTRScenesClusterGetSceneMembershipParams *)params
                   completionHandler:(void (^)(MTRScenesClusterGetSceneMembershipResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self getSceneMembershipWithParams:params completion:completionHandler];
}
- (void)enhancedAddSceneWithParams:(MTRScenesClusterEnhancedAddSceneParams *)params
                 completionHandler:(void (^)(MTRScenesClusterEnhancedAddSceneResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self enhancedAddSceneWithParams:params completion:completionHandler];
}
- (void)enhancedViewSceneWithParams:(MTRScenesClusterEnhancedViewSceneParams *)params
                  completionHandler:(void (^)(MTRScenesClusterEnhancedViewSceneResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    [self enhancedViewSceneWithParams:params completion:completionHandler];
}
- (void)copySceneWithParams:(MTRScenesClusterCopySceneParams *)params
          completionHandler:
              (void (^)(MTRScenesClusterCopySceneResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self copySceneWithParams:params completion:completionHandler];
}

- (void)readAttributeSceneCountWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSceneCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeSceneCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSceneCountWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeSceneCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSceneCountWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeCurrentSceneWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSceneWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentSceneWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentSceneWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeCurrentSceneWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSceneWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeCurrentGroupWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentGroupWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentGroupWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentGroupWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeCurrentGroupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentGroupWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSceneValidWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSceneValidWithCompletion:completionHandler];
}
- (void)subscribeAttributeSceneValidWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSceneValidWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeSceneValidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSceneValidWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeNameSupportWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNameSupportWithCompletion:completionHandler];
}
- (void)subscribeAttributeNameSupportWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNameSupportWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeNameSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNameSupportWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeLastConfiguredByWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConfiguredByWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeLastConfiguredByWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLastConfiguredByWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeLastConfiguredByWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConfiguredByWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOnOff

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            OnOff::Commands::Off::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            OnOff::Commands::On::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            OnOff::Commands::Toggle::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            OnOff::Commands::OnWithRecallGlobalScene::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGlobalSceneControlWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGlobalSceneControlWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOffWaitTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOffWaitTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpOnOffWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartUpOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableOnOffClusterOnOffStartUpOnOffAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(OnOffGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAcceptedCommandListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAcceptedCommandListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(OnOffAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OnOffAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROnOffAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::AttributeList::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(OnOffAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OnOffCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOnOff (Deprecated)

- (void)offWithParams:(MTROnOffClusterOffParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self offWithParams:params completion:completionHandler];
}
- (void)offWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self offWithParams:nil completion:completionHandler];
}
- (void)onWithParams:(MTROnOffClusterOnParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithParams:params completion:completionHandler];
}
- (void)onWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithParams:nil completion:completionHandler];
}
- (void)toggleWithParams:(MTROnOffClusterToggleParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self toggleWithParams:params completion:completionHandler];
}
- (void)toggleWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self toggleWithParams:nil completion:completionHandler];
}
- (void)offWithEffectWithParams:(MTROnOffClusterOffWithEffectParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self offWithEffectWithParams:params completion:completionHandler];
}
- (void)onWithRecallGlobalSceneWithParams:(MTROnOffClusterOnWithRecallGlobalSceneParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithRecallGlobalSceneWithParams:params completion:completionHandler];
}
- (void)onWithRecallGlobalSceneWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithRecallGlobalSceneWithParams:nil completion:completionHandler];
}
- (void)onWithTimedOffWithParams:(MTROnOffClusterOnWithTimedOffParams *)params
               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self onWithTimedOffWithParams:params completion:completionHandler];
}

- (void)readAttributeOnOffWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffWithCompletion:completionHandler];
}
- (void)subscribeAttributeOnOffWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnOffWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeGlobalSceneControlWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeGlobalSceneControlWithCompletion:completionHandler];
}
- (void)subscribeAttributeGlobalSceneControlWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGlobalSceneControlWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeGlobalSceneControlWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGlobalSceneControlWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeOnTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTimeWithCompletion:completionHandler];
}
- (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOnTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnTimeWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeOnTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTimeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeOffWaitTimeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffWaitTimeWithCompletion:completionHandler];
}
- (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOffWaitTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOffWaitTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOffWaitTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOffWaitTimeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeOffWaitTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffWaitTimeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStartUpOnOffWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpOnOffWithCompletion:completionHandler];
}
- (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpOnOffWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpOnOffWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeStartUpOnOffWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartUpOnOffWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeStartUpOnOffWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpOnOffWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOnOffSwitchConfiguration

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

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

- (void)readAttributeSwitchTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSwitchTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSwitchActionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSwitchActionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OnOffSwitchConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OnOffSwitchConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOnOffSwitchConfiguration (Deprecated)

- (void)readAttributeSwitchTypeWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeSwitchTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSwitchTypeWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeSwitchTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchTypeWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeSwitchActionsWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchActionsWithCompletion:completionHandler];
}
- (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSwitchActionsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSwitchActionsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSwitchActionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSwitchActionsWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeSwitchActionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSwitchActionsWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterLevelControl

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

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

- (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepWithParams:(MTRLevelControlClusterStepParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stopWithParams:(MTRLevelControlClusterStopParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOffTransitionTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDefaultMoveRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDefaultMoveRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpCurrentLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartUpCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LevelControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LevelControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLevelControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(LevelControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::LevelControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLevelControl (Deprecated)

- (void)moveToLevelWithParams:(MTRLevelControlClusterMoveToLevelParams *)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToLevelWithParams:params completion:completionHandler];
}
- (void)moveWithParams:(MTRLevelControlClusterMoveParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveWithParams:params completion:completionHandler];
}
- (void)stepWithParams:(MTRLevelControlClusterStepParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepWithParams:params completion:completionHandler];
}
- (void)stopWithParams:(MTRLevelControlClusterStopParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopWithParams:params completion:completionHandler];
}
- (void)moveToLevelWithOnOffWithParams:(MTRLevelControlClusterMoveToLevelWithOnOffParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToLevelWithOnOffWithParams:params completion:completionHandler];
}
- (void)moveWithOnOffWithParams:(MTRLevelControlClusterMoveWithOnOffParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveWithOnOffWithParams:params completion:completionHandler];
}
- (void)stepWithOnOffWithParams:(MTRLevelControlClusterStepWithOnOffParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepWithOnOffWithParams:params completion:completionHandler];
}
- (void)stopWithOnOffWithParams:(MTRLevelControlClusterStopWithOnOffParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopWithOnOffWithParams:params completion:completionHandler];
}
- (void)moveToClosestFrequencyWithParams:(MTRLevelControlClusterMoveToClosestFrequencyParams *)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToClosestFrequencyWithParams:params completion:completionHandler];
}

- (void)readAttributeCurrentLevelWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentLevelWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentLevelWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentLevelWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithCompletion:completionHandler];
}
- (void)subscribeAttributeRemainingTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRemainingTimeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinLevelWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinLevelWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeMaxLevelWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxLevelWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeCurrentFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFrequencyWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeCurrentFrequencyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentFrequencyWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeCurrentFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFrequencyWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMinFrequencyWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinFrequencyWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinFrequencyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinFrequencyWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMinFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinFrequencyWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeMaxFrequencyWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFrequencyWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxFrequencyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxFrequencyWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMaxFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFrequencyWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithCompletion:completionHandler];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOptionsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOptionsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOptionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOptionsWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeOnOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffTransitionTimeWithCompletion:completionHandler];
}
- (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnOffTransitionTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnOffTransitionTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOnOffTransitionTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnOffTransitionTimeWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeOnOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnOffTransitionTimeWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeOnLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnLevelWithCompletion:completionHandler];
}
- (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnLevelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnLevelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOnLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnLevelWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeOnLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnLevelWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeOnTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTransitionTimeWithCompletion:completionHandler];
}
- (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnTransitionTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnTransitionTimeWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeOnTransitionTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnTransitionTimeWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeOnTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnTransitionTimeWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeOffTransitionTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeOffTransitionTimeWithCompletion:completionHandler];
}
- (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOffTransitionTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOffTransitionTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOffTransitionTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOffTransitionTimeWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeOffTransitionTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOffTransitionTimeWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeDefaultMoveRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultMoveRateWithCompletion:completionHandler];
}
- (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDefaultMoveRateWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDefaultMoveRateWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeDefaultMoveRateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDefaultMoveRateWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeDefaultMoveRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultMoveRateWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeStartUpCurrentLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpCurrentLevelWithCompletion:completionHandler];
}
- (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpCurrentLevelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpCurrentLevelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeStartUpCurrentLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartUpCurrentLevelWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeStartUpCurrentLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpCurrentLevelWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBinaryInputBasic

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

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

- (void)readAttributeActiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInactiveTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInactiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOutOfServiceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOutOfServiceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePolarityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePolarityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePresentValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePresentValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReliabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReliabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStatusFlagsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStatusFlagsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApplicationTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BinaryInputBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BinaryInputBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BinaryInputBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BinaryInputBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBinaryInputBasic (Deprecated)

- (void)readAttributeActiveTextWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTextWithCompletion:completionHandler];
}
- (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveTextWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveTextWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeActiveTextWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveTextWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeActiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTextWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeDescriptionWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithCompletion:completionHandler];
}
- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDescriptionWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDescriptionWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeDescriptionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDescriptionWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeInactiveTextWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInactiveTextWithCompletion:completionHandler];
}
- (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInactiveTextWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInactiveTextWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInactiveTextWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInactiveTextWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeInactiveTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInactiveTextWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeOutOfServiceWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutOfServiceWithCompletion:completionHandler];
}
- (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOutOfServiceWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOutOfServiceWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOutOfServiceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOutOfServiceWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeOutOfServiceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutOfServiceWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributePolarityWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePolarityWithCompletion:completionHandler];
}
- (void)subscribeAttributePolarityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePolarityWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributePolarityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePolarityWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributePresentValueWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePresentValueWithCompletion:completionHandler];
}
- (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePresentValueWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePresentValueWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePresentValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePresentValueWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributePresentValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePresentValueWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeReliabilityWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReliabilityWithCompletion:completionHandler];
}
- (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeReliabilityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeReliabilityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeReliabilityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReliabilityWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeReliabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReliabilityWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStatusFlagsWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusFlagsWithCompletion:completionHandler];
}
- (void)subscribeAttributeStatusFlagsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStatusFlagsWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeStatusFlagsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusFlagsWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeApplicationTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeApplicationTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApplicationTypeWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeApplicationTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationTypeWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterDescriptor

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

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

- (void)readAttributeDeviceTypeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorDeviceTypeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorDeviceTypeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::DeviceTypeList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDeviceTypeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DescriptorDeviceTypeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeServerListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorServerListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorServerListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorServerListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorServerListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ServerList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorServerListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeServerListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorServerListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DescriptorServerListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClientListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorClientListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorClientListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorClientListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorClientListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ClientList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorClientListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClientListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorClientListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DescriptorClientListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartsListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorPartsListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorPartsListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::PartsList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePartsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorPartsListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DescriptorPartsListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DescriptorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DescriptorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DescriptorAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::AttributeList::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDescriptorAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DescriptorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::DescriptorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDescriptor (Deprecated)

- (void)readAttributeDeviceListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDeviceTypeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeDeviceListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDeviceTypeListWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeDeviceListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDeviceTypeListWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeServerListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeServerListWithCompletion:completionHandler];
}
- (void)subscribeAttributeServerListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeServerListWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeServerListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeServerListWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClientListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClientListWithCompletion:completionHandler];
}
- (void)subscribeAttributeClientListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClientListWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeClientListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClientListWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributePartsListWithCompletionHandler:(void (^)(
                                                        NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartsListWithCompletion:completionHandler];
}
- (void)subscribeAttributePartsListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePartsListWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePartsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartsListWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBinding

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRBindingBindingListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingBindingListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBindingBindingListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingBindingListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBindingBindingListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::Binding::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingBindingListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBindingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingBindingListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BindingBindingListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BindingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BindingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BindingAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBindingAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::AttributeList::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBindingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBindingAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BindingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BindingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBinding (Deprecated)

- (void)readAttributeBindingWithParams:(MTRReadParams * _Nullable)params
                     completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBindingWithParams:params completion:completionHandler];
}
- (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBindingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBindingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBindingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBindingWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeBindingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBindingWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterAccessControl

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRAccessControlAclListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlAclListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccessControlAclListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlAclListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccessControlAclListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlAclListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAclWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                  endpoint:(NSNumber *)endpoint
                                     queue:(dispatch_queue_t)queue
                                completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlAclListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(AccessControlAclListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, 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];
    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlExtensionListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AccessControlExtensionListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeExtensionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlExtensionListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(AccessControlExtensionListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSubjectsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSubjectsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTargetsPerAccessControlEntryWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTargetsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAccessControlEntriesPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAccessControlEntriesPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AccessControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AccessControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccessControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AccessControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::AccessControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAccessControl (Deprecated)

- (void)readAttributeAclWithParams:(MTRReadParams * _Nullable)params
                 completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAclWithParams:params completion:completionHandler];
}
- (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAclWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeAclWithValue:(NSArray * _Nonnull)value
                            params:(MTRWriteParams * _Nullable)params
                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAclWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeAclWithMinInterval:(NSNumber * _Nonnull)minInterval
                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                      params:(MTRSubscribeParams * _Nullable)params
                     subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                               reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAclWithParams:subscribeParams
                  subscriptionEstablished:subscriptionEstablishedHandler
                            reportHandler:reportHandler];
}
+ (void)readAttributeAclWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                  endpoint:(NSNumber *)endpoint
                                     queue:(dispatch_queue_t)queue
                         completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAclWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeExtensionWithParams:(MTRReadParams * _Nullable)params
                       completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtensionWithParams:params completion:completionHandler];
}
- (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeExtensionWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeExtensionWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeExtensionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeExtensionWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeExtensionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtensionWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeSubjectsPerAccessControlEntryWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeSubjectsPerAccessControlEntryWithCompletion:completionHandler];
}
- (void)subscribeAttributeSubjectsPerAccessControlEntryWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSubjectsPerAccessControlEntryWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeSubjectsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeSubjectsPerAccessControlEntryWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeTargetsPerAccessControlEntryWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetsPerAccessControlEntryWithCompletion:completionHandler];
}
- (void)subscribeAttributeTargetsPerAccessControlEntryWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTargetsPerAccessControlEntryWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeTargetsPerAccessControlEntryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetsPerAccessControlEntryWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeAccessControlEntriesPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeAccessControlEntriesPerFabricWithCompletion:completionHandler];
}
- (void)subscribeAttributeAccessControlEntriesPerFabricWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAccessControlEntriesPerFabricWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeAccessControlEntriesPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeAccessControlEntriesPerFabricWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterActions

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

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

- (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params
                                   completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params
                                completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeActionListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsActionListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsActionListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRActionsActionListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsActionListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRActionsActionListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::ActionList::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsActionListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActionListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsActionListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ActionsActionListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEndpointListsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsEndpointListsListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsEndpointListsListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::EndpointLists::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEndpointListsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsEndpointListsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ActionsEndpointListsListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetupURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::SetupURL::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSetupURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ActionsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ActionsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ActionsAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRActionsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::AttributeList::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRActionsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRActionsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ActionsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Actions::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ActionsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterActions (Deprecated)

- (void)instantActionWithParams:(MTRActionsClusterInstantActionParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self instantActionWithParams:params completion:completionHandler];
}
- (void)instantActionWithTransitionWithParams:(MTRActionsClusterInstantActionWithTransitionParams *)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self instantActionWithTransitionWithParams:params completion:completionHandler];
}
- (void)startActionWithParams:(MTRActionsClusterStartActionParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self startActionWithParams:params completion:completionHandler];
}
- (void)startActionWithDurationWithParams:(MTRActionsClusterStartActionWithDurationParams *)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self startActionWithDurationWithParams:params completion:completionHandler];
}
- (void)stopActionWithParams:(MTRActionsClusterStopActionParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopActionWithParams:params completion:completionHandler];
}
- (void)pauseActionWithParams:(MTRActionsClusterPauseActionParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self pauseActionWithParams:params completion:completionHandler];
}
- (void)pauseActionWithDurationWithParams:(MTRActionsClusterPauseActionWithDurationParams *)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self pauseActionWithDurationWithParams:params completion:completionHandler];
}
- (void)resumeActionWithParams:(MTRActionsClusterResumeActionParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resumeActionWithParams:params completion:completionHandler];
}
- (void)enableActionWithParams:(MTRActionsClusterEnableActionParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enableActionWithParams:params completion:completionHandler];
}
- (void)enableActionWithDurationWithParams:(MTRActionsClusterEnableActionWithDurationParams *)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enableActionWithDurationWithParams:params completion:completionHandler];
}
- (void)disableActionWithParams:(MTRActionsClusterDisableActionParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self disableActionWithParams:params completion:completionHandler];
}
- (void)disableActionWithDurationWithParams:(MTRActionsClusterDisableActionWithDurationParams *)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self disableActionWithDurationWithParams:params completion:completionHandler];
}

- (void)readAttributeActionListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActionListWithCompletion:completionHandler];
}
- (void)subscribeAttributeActionListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActionListWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeActionListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActionListWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeEndpointListsWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndpointListsWithCompletion:completionHandler];
}
- (void)subscribeAttributeEndpointListsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEndpointListsWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeEndpointListsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndpointListsWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeSetupURLWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetupURLWithCompletion:completionHandler];
}
- (void)subscribeAttributeSetupURLWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSetupURLWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeSetupURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetupURLWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBasic

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Basic::Commands::MfgSpecificPing::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeDataModelRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDataModelRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::NodeLabel::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::Location::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::Location::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalConfigDisabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::LocalConfigDisabled::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocalConfigDisabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCapabilityMinimaWithCompletion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicCapabilityMinimaStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicCapabilityMinimaStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCapabilityMinimaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                            NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BasicCapabilityMinimaStructAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAcceptedCommandListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAcceptedCommandListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BasicAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::AttributeList::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBasicAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBasic (Deprecated)

- (void)mfgSpecificPingWithParams:(MTRBasicClusterMfgSpecificPingParams * _Nullable)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self mfgSpecificPingWithParams:params completion:completionHandler];
}
- (void)mfgSpecificPingWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self mfgSpecificPingWithParams:nil completion:completionHandler];
}

- (void)readAttributeDataModelRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeDataModelRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeDataModelRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDataModelRevisionWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeDataModelRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataModelRevisionWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorNameWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorIDWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeProductNameWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductNameWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeProductIDWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductIDWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeNodeLabelWithCompletionHandler:(void (^)(
                                                        NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithCompletion:completionHandler];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNodeLabelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNodeLabelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNodeLabelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNodeLabelWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeLocationWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationWithCompletion:completionHandler];
}
- (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLocationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocationWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeLocationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeHardwareVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHardwareVersionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithCompletion:completionHandler];
}
- (void)subscribeAttributeHardwareVersionStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHardwareVersionStringWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeSoftwareVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSoftwareVersionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithCompletion:completionHandler];
}
- (void)subscribeAttributeSoftwareVersionStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSoftwareVersionStringWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithCompletion:completionHandler];
}
- (void)subscribeAttributeManufacturingDateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeManufacturingDateWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePartNumberWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithCompletion:completionHandler];
}
- (void)subscribeAttributePartNumberWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePartNumberWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeProductURLWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductURLWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductURLWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeProductLabelWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductLabelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductLabelWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSerialNumberWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithCompletion:completionHandler];
}
- (void)subscribeAttributeSerialNumberWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSerialNumberWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeLocalConfigDisabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalConfigDisabledWithCompletion:completionHandler];
}
- (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalConfigDisabledWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalConfigDisabledWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLocalConfigDisabledWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocalConfigDisabledWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeLocalConfigDisabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalConfigDisabledWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeReachableWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithCompletion:completionHandler];
}
- (void)subscribeAttributeReachableWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReachableWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeUniqueIDWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeUniqueIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUniqueIDWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeCapabilityMinimaWithCompletionHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeCapabilityMinimaWithCompletion:completionHandler];
}
- (void)subscribeAttributeCapabilityMinimaWithMinInterval:(NSNumber * _Nonnull)minInterval
                                              maxInterval:(NSNumber * _Nonnull)maxInterval
                                                   params:(MTRSubscribeParams * _Nullable)params
                                  subscriptionEstablished:
                                      (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                            reportHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                              NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCapabilityMinimaWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeCapabilityMinimaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:(void (^)(MTRBasicClusterCapabilityMinimaStruct * _Nullable value,
                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeCapabilityMinimaWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateProvider

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTROtaSoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateProviderGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateProviderAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateProviderAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateProvider (Deprecated)

- (void)queryImageWithParams:(MTROtaSoftwareUpdateProviderClusterQueryImageParams *)params
           completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    [self queryImageWithParams:params completion:completionHandler];
}
- (void)applyUpdateRequestWithParams:(MTROtaSoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
                   completionHandler:(void (^)(MTROtaSoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self applyUpdateRequestWithParams:params completion:completionHandler];
}
- (void)notifyUpdateAppliedWithParams:(MTROtaSoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self notifyUpdateAppliedWithParams:params completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateRequestor

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

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

- (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnounceOtaProviderParams *)params
                           completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOtaProviders::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDefaultOtaProvidersWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeUpdatePossibleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUpdatePossibleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUpdateStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
                chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUpdateStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeUpdateStateProgressWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUpdateStateProgressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateRequestorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateRequestorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROtaSoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OtaSoftwareUpdateRequestorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOtaSoftwareUpdateRequestor (Deprecated)

- (void)announceOtaProviderWithParams:(MTROtaSoftwareUpdateRequestorClusterAnnounceOtaProviderParams *)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self announceOtaProviderWithParams:params completion:completionHandler];
}

- (void)readAttributeDefaultOtaProvidersWithParams:(MTRReadParams * _Nullable)params
                                 completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultOtaProvidersWithParams:params completion:completionHandler];
}
- (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDefaultOtaProvidersWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeDefaultOtaProvidersWithValue:(NSArray * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDefaultOtaProvidersWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeDefaultOtaProvidersWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDefaultOtaProvidersWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeDefaultOtaProvidersWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultOtaProvidersWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeUpdatePossibleWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdatePossibleWithCompletion:completionHandler];
}
- (void)subscribeAttributeUpdatePossibleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUpdatePossibleWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeUpdatePossibleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdatePossibleWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeUpdateStateWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeUpdateStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUpdateStateWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeUpdateStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeUpdateStateProgressWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateProgressWithCompletion:completionHandler];
}
- (void)subscribeAttributeUpdateStateProgressWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUpdateStateProgressWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeUpdateStateProgressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpdateStateProgressWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterLocalizationConfiguration

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

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

- (void)readAttributeActiveLocaleWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveLocaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedLocalesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedLocalesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LocalizationConfigurationSupportedLocalesListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LocalizationConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LocalizationConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LocalizationConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::LocalizationConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLocalizationConfiguration (Deprecated)

- (void)readAttributeActiveLocaleWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveLocaleWithCompletion:completionHandler];
}
- (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveLocaleWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveLocaleWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeActiveLocaleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveLocaleWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeActiveLocaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveLocaleWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSupportedLocalesWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedLocalesWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeSupportedLocalesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedLocalesWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeSupportedLocalesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedLocalesWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterTimeFormatLocalization

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

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

- (void)readAttributeHourFormatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHourFormatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationClusterHourFormatAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveCalendarTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveCalendarTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationClusterCalendarTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedCalendarTypesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedCalendarTypesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TimeFormatLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::TimeFormatLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTimeFormatLocalization (Deprecated)

- (void)readAttributeHourFormatWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHourFormatWithCompletion:completionHandler];
}
- (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeHourFormatWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeHourFormatWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeHourFormatWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHourFormatWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeHourFormatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHourFormatWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeActiveCalendarTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCalendarTypeWithCompletion:completionHandler];
}
- (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveCalendarTypeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeActiveCalendarTypeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeActiveCalendarTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveCalendarTypeWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeActiveCalendarTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCalendarTypeWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeSupportedCalendarTypesWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedCalendarTypesWithCompletion:completionHandler];
}
- (void)subscribeAttributeSupportedCalendarTypesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedCalendarTypesWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeSupportedCalendarTypesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedCalendarTypesWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterUnitLocalization

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

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

- (void)readAttributeTemperatureUnitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTemperatureUnitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UnitLocalizationClusterTempUnitAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UnitLocalizationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UnitLocalizationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::AttributeList::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UnitLocalizationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::UnitLocalizationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterUnitLocalization (Deprecated)

- (void)readAttributeTemperatureUnitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureUnitWithCompletion:completionHandler];
}
- (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureUnitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureUnitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeTemperatureUnitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTemperatureUnitWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeTemperatureUnitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureUnitWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterPowerSourceConfiguration

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

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

- (void)readAttributeSourcesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSourcesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceConfigurationSourcesListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::PowerSourceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPowerSourceConfiguration (Deprecated)

- (void)readAttributeSourcesWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSourcesWithCompletion:completionHandler];
}
- (void)subscribeAttributeSourcesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSourcesWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeSourcesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSourcesWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterPowerSource

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

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

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceClusterPowerSourceStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeOrderWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOrderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredAssessedInputVoltageWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredAssessedInputVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredAssessedInputFrequencyWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredAssessedInputFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredCurrentTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredCurrentTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceClusterWiredCurrentTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWiredAssessedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredAssessedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredNominalVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredNominalVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredMaximumCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredMaximumCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWiredPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiredPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveWiredFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveWiredFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceActiveWiredFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatVoltage::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatPercentRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatPercentRemaining::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatPercentRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatTimeRemainingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatTimeRemaining::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatTimeRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargeLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargeLevel::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatChargeLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceClusterBatChargeLevelAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatReplacementNeededWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplacementNeeded::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatReplacementNeededWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatReplaceabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplaceability::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatReplaceabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceClusterBatReplaceabilityAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatPresentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatPresent::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveBatFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveBatFaults::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveBatFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceActiveBatFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatReplacementDescriptionWithCompletion:(void (^)(
                                                                 NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatReplacementDescription::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatReplacementDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSString * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatCommonDesignationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatCommonDesignation::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatCommonDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatANSIDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatANSIDesignation::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatANSIDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatIECDesignationWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatIECDesignation::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatIECDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatApprovedChemistryWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatApprovedChemistry::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatApprovedChemistryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatCapacity::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatQuantity::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargeState::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatChargeStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceClusterBatChargeStateAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeBatTimeToFullChargeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatTimeToFullCharge::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatTimeToFullChargeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatFunctionalWhileChargingWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatFunctionalWhileCharging::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatFunctionalWhileChargingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBatChargingCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::BatChargingCurrent::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBatChargingCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveBatChargeFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ActiveBatChargeFaults::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveBatChargeFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceActiveBatChargeFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PowerSourceAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, PowerSourceAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, PowerSourceAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::AttributeList::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(PowerSourceAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::PowerSourceCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPowerSource (Deprecated)

- (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStatusWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeOrderWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOrderWithCompletion:completionHandler];
}
- (void)subscribeAttributeOrderWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOrderWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeOrderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOrderWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeDescriptionWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithCompletion:completionHandler];
}
- (void)subscribeAttributeDescriptionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDescriptionWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeWiredAssessedInputVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredAssessedInputVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredAssessedInputVoltageWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeWiredAssessedInputVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputVoltageWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeWiredAssessedInputFrequencyWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputFrequencyWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredAssessedInputFrequencyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredAssessedInputFrequencyWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeWiredAssessedInputFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedInputFrequencyWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeWiredCurrentTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredCurrentTypeWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeWiredCurrentTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredCurrentTypeWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeWiredCurrentTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredCurrentTypeWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeWiredAssessedCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredAssessedCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredAssessedCurrentWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeWiredAssessedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredAssessedCurrentWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeWiredNominalVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredNominalVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredNominalVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredNominalVoltageWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeWiredNominalVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredNominalVoltageWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeWiredMaximumCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredMaximumCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredMaximumCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredMaximumCurrentWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeWiredMaximumCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredMaximumCurrentWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeWiredPresentWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredPresentWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiredPresentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiredPresentWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeWiredPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiredPresentWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeActiveWiredFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveWiredFaultsWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeActiveWiredFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveWiredFaultsWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeActiveWiredFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveWiredFaultsWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeBatVoltageWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatVoltageWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeBatVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatVoltageWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeBatPercentRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPercentRemainingWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatPercentRemainingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatPercentRemainingWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeBatPercentRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPercentRemainingWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeBatTimeRemainingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeRemainingWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeBatTimeRemainingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatTimeRemainingWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeBatTimeRemainingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeRemainingWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeBatChargeLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeLevelWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatChargeLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatChargeLevelWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeBatChargeLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeLevelWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeBatReplacementNeededWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementNeededWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatReplacementNeededWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatReplacementNeededWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeBatReplacementNeededWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementNeededWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeBatReplaceabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplaceabilityWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatReplaceabilityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatReplaceabilityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeBatReplaceabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplaceabilityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeBatPresentWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPresentWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatPresentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatPresentWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeBatPresentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatPresentWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeActiveBatFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatFaultsWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveBatFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveBatFaultsWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeActiveBatFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatFaultsWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeBatReplacementDescriptionWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementDescriptionWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatReplacementDescriptionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSString * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatReplacementDescriptionWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeBatReplacementDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSString * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeBatReplacementDescriptionWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeBatCommonDesignationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCommonDesignationWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatCommonDesignationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatCommonDesignationWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeBatCommonDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCommonDesignationWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeBatANSIDesignationWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeBatANSIDesignationWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatANSIDesignationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatANSIDesignationWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeBatANSIDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatANSIDesignationWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeBatIECDesignationWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeBatIECDesignationWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatIECDesignationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatIECDesignationWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeBatIECDesignationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatIECDesignationWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeBatApprovedChemistryWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeBatApprovedChemistryWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatApprovedChemistryWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatApprovedChemistryWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeBatApprovedChemistryWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatApprovedChemistryWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeBatCapacityWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCapacityWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatCapacityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatCapacityWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeBatCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatCapacityWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeBatQuantityWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatQuantityWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatQuantityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatQuantityWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeBatQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatQuantityWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeBatChargeStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatChargeStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatChargeStateWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeBatChargeStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargeStateWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeBatTimeToFullChargeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeToFullChargeWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatTimeToFullChargeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatTimeToFullChargeWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeBatTimeToFullChargeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatTimeToFullChargeWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeBatFunctionalWhileChargingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeBatFunctionalWhileChargingWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatFunctionalWhileChargingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatFunctionalWhileChargingWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeBatFunctionalWhileChargingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeBatFunctionalWhileChargingWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeBatChargingCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargingCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeBatChargingCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBatChargingCurrentWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeBatChargingCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBatChargingCurrentWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeActiveBatChargeFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatChargeFaultsWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveBatChargeFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveBatChargeFaultsWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeActiveBatChargeFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveBatChargeFaultsWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterGeneralCommissioning

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterArmFailSafeResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterCommissioningCompleteResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            GeneralCommissioning::Commands::CommissioningComplete::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeBreadcrumbWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBreadcrumbWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBasicCommissioningInfoWithCompletion:
    (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBasicCommissioningInfoWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(
                                                           MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningBasicCommissioningInfoStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRegulatoryConfigWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRegulatoryConfigWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLocationCapabilityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocationCapabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportsConcurrentConnectionWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportsConcurrentConnectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::GeneralCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGeneralCommissioning (Deprecated)

- (void)armFailSafeWithParams:(MTRGeneralCommissioningClusterArmFailSafeParams *)params
            completionHandler:(void (^)(MTRGeneralCommissioningClusterArmFailSafeResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    [self armFailSafeWithParams:params completion:completionHandler];
}
- (void)setRegulatoryConfigWithParams:(MTRGeneralCommissioningClusterSetRegulatoryConfigParams *)params
                    completionHandler:(void (^)(MTRGeneralCommissioningClusterSetRegulatoryConfigResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    [self setRegulatoryConfigWithParams:params completion:completionHandler];
}
- (void)commissioningCompleteWithParams:(MTRGeneralCommissioningClusterCommissioningCompleteParams * _Nullable)params
                      completionHandler:
                          (void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    [self commissioningCompleteWithParams:params completion:completionHandler];
}
- (void)commissioningCompleteWithCompletionHandler:
    (void (^)(MTRGeneralCommissioningClusterCommissioningCompleteResponseParams * _Nullable data,
        NSError * _Nullable error))completionHandler
{
    [self commissioningCompleteWithParams:nil completion:completionHandler];
}

- (void)readAttributeBreadcrumbWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBreadcrumbWithCompletion:completionHandler];
}
- (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBreadcrumbWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBreadcrumbWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBreadcrumbWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBreadcrumbWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeBreadcrumbWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBreadcrumbWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeBasicCommissioningInfoWithCompletionHandler:
    (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBasicCommissioningInfoWithCompletion:completionHandler];
}
- (void)subscribeAttributeBasicCommissioningInfoWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(
                                                          MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBasicCommissioningInfoWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeBasicCommissioningInfoWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(MTRGeneralCommissioningClusterBasicCommissioningInfo * _Nullable value,
                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeBasicCommissioningInfoWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeRegulatoryConfigWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRegulatoryConfigWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRegulatoryConfigWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRegulatoryConfigWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRegulatoryConfigWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRegulatoryConfigWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeLocationCapabilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationCapabilityWithCompletion:completionHandler];
}
- (void)subscribeAttributeLocationCapabilityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocationCapabilityWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeLocationCapabilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocationCapabilityWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeSupportsConcurrentConnectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportsConcurrentConnectionWithCompletion:completionHandler];
}
- (void)subscribeAttributeSupportsConcurrentConnectionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportsConcurrentConnectionWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeSupportsConcurrentConnectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportsConcurrentConnectionWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterNetworkCommissioning

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterScanNetworksResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
                }
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterConnectNetworkResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningClusterNetworkConfigResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeMaxNetworksWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNetworksWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::Networks::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NetworkCommissioningNetworksListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeScanMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeScanMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeConnectMaxTimeSecondsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeConnectMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInterfaceEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInterfaceEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastNetworkingStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(self.callbackQueue,
        completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<
                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLastNetworkingStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLastNetworkIDWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLastNetworkIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLastConnectErrorValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLastConnectErrorValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NetworkCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NetworkCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NetworkCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::NetworkCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterNetworkCommissioning (Deprecated)

- (void)scanNetworksWithParams:(MTRNetworkCommissioningClusterScanNetworksParams * _Nullable)params
             completionHandler:(void (^)(MTRNetworkCommissioningClusterScanNetworksResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self scanNetworksWithParams:params completion:completionHandler];
}
- (void)addOrUpdateWiFiNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateWiFiNetworkParams *)params
                       completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                             NSError * _Nullable error))completionHandler
{
    [self addOrUpdateWiFiNetworkWithParams:params completion:completionHandler];
}
- (void)addOrUpdateThreadNetworkWithParams:(MTRNetworkCommissioningClusterAddOrUpdateThreadNetworkParams *)params
                         completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                               NSError * _Nullable error))completionHandler
{
    [self addOrUpdateThreadNetworkWithParams:params completion:completionHandler];
}
- (void)removeNetworkWithParams:(MTRNetworkCommissioningClusterRemoveNetworkParams *)params
              completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    [self removeNetworkWithParams:params completion:completionHandler];
}
- (void)connectNetworkWithParams:(MTRNetworkCommissioningClusterConnectNetworkParams *)params
               completionHandler:(void (^)(MTRNetworkCommissioningClusterConnectNetworkResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    [self connectNetworkWithParams:params completion:completionHandler];
}
- (void)reorderNetworkWithParams:(MTRNetworkCommissioningClusterReorderNetworkParams *)params
               completionHandler:(void (^)(MTRNetworkCommissioningClusterNetworkConfigResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    [self reorderNetworkWithParams:params completion:completionHandler];
}

- (void)readAttributeMaxNetworksWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxNetworksWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxNetworksWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxNetworksWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeMaxNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxNetworksWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeNetworksWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworksWithCompletion:completionHandler];
}
- (void)subscribeAttributeNetworksWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNetworksWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeNetworksWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworksWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeScanMaxTimeSecondsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeScanMaxTimeSecondsWithCompletion:completionHandler];
}
- (void)subscribeAttributeScanMaxTimeSecondsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeScanMaxTimeSecondsWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeScanMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScanMaxTimeSecondsWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeConnectMaxTimeSecondsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeConnectMaxTimeSecondsWithCompletion:completionHandler];
}
- (void)subscribeAttributeConnectMaxTimeSecondsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeConnectMaxTimeSecondsWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeConnectMaxTimeSecondsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConnectMaxTimeSecondsWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeInterfaceEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeInterfaceEnabledWithCompletion:completionHandler];
}
- (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInterfaceEnabledWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInterfaceEnabledWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeInterfaceEnabledWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInterfaceEnabledWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeInterfaceEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInterfaceEnabledWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeLastNetworkingStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkingStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeLastNetworkingStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLastNetworkingStatusWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeLastNetworkingStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkingStatusWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeLastNetworkIDWithCompletionHandler:(void (^)(
                                                            NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeLastNetworkIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLastNetworkIDWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeLastNetworkIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastNetworkIDWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeLastConnectErrorValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConnectErrorValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeLastConnectErrorValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLastConnectErrorValueWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeLastConnectErrorValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLastConnectErrorValueWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterDiagnosticLogs

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsClusterRetrieveLogsResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DiagnosticLogsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DiagnosticLogsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::TypeInfo;

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DiagnosticLogsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::DiagnosticLogsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDiagnosticLogs (Deprecated)

- (void)retrieveLogsRequestWithParams:(MTRDiagnosticLogsClusterRetrieveLogsRequestParams *)params
                    completionHandler:(void (^)(MTRDiagnosticLogsClusterRetrieveLogsResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    [self retrieveLogsRequestWithParams:params completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterGeneralDiagnostics

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

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

- (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTriggerParams *)params
                        completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeNetworkInterfacesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNetworkInterfacesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsNetworkInterfacesListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRebootCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRebootCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUpTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUpTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalOperationalHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTotalOperationalHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBootReasonsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBootReasonsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveHardwareFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveHardwareFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveRadioFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveRadioFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsActiveRadioFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveNetworkFaultsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveNetworkFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeTestEventTriggersEnabledWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::TestEventTriggersEnabled::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTestEventTriggersEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GeneralDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::GeneralDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGeneralDiagnostics (Deprecated)

- (void)testEventTriggerWithParams:(MTRGeneralDiagnosticsClusterTestEventTriggerParams *)params
                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testEventTriggerWithParams:params completion:completionHandler];
}

- (void)readAttributeNetworkInterfacesWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkInterfacesWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeNetworkInterfacesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNetworkInterfacesWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeNetworkInterfacesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkInterfacesWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRebootCountWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRebootCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRebootCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRebootCountWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeRebootCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRebootCountWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeUpTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpTimeWithCompletion:completionHandler];
}
- (void)subscribeAttributeUpTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUpTimeWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeUpTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUpTimeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeTotalOperationalHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalOperationalHoursWithCompletion:completionHandler];
}
- (void)subscribeAttributeTotalOperationalHoursWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTotalOperationalHoursWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeTotalOperationalHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalOperationalHoursWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeBootReasonsWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBootReasonsWithCompletion:completionHandler];
}
- (void)subscribeAttributeBootReasonsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBootReasonsWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeBootReasonsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBootReasonsWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeActiveHardwareFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveHardwareFaultsWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveHardwareFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveHardwareFaultsWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeActiveHardwareFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveHardwareFaultsWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeActiveRadioFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveRadioFaultsWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeActiveRadioFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveRadioFaultsWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeActiveRadioFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveRadioFaultsWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeActiveNetworkFaultsWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveNetworkFaultsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveNetworkFaultsWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeActiveNetworkFaultsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeTestEventTriggersEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeTestEventTriggersEnabledWithCompletion:completionHandler];
}
- (void)subscribeAttributeTestEventTriggersEnabledWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTestEventTriggersEnabledWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeTestEventTriggersEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTestEventTriggersEnabledWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterSoftwareDiagnostics

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            SoftwareDiagnostics::Commands::ResetWatermarks::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeThreadMetricsWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeThreadMetricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(SoftwareDiagnosticsThreadMetricsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentHeapFreeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentHeapFreeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentHeapUsedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentHeapUsedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentHeapHighWatermarkWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentHeapHighWatermarkWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(SoftwareDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(SoftwareDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(SoftwareDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::SoftwareDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterSoftwareDiagnostics (Deprecated)

- (void)resetWatermarksWithParams:(MTRSoftwareDiagnosticsClusterResetWatermarksParams * _Nullable)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetWatermarksWithParams:params completion:completionHandler];
}
- (void)resetWatermarksWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetWatermarksWithParams:nil completion:completionHandler];
}

- (void)readAttributeThreadMetricsWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThreadMetricsWithCompletion:completionHandler];
}
- (void)subscribeAttributeThreadMetricsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeThreadMetricsWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeThreadMetricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThreadMetricsWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeCurrentHeapFreeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapFreeWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentHeapFreeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentHeapFreeWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeCurrentHeapFreeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapFreeWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeCurrentHeapUsedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapUsedWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentHeapUsedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentHeapUsedWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeCurrentHeapUsedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapUsedWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeCurrentHeapHighWatermarkWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapHighWatermarkWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentHeapHighWatermarkWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentHeapHighWatermarkWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeCurrentHeapHighWatermarkWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHeapHighWatermarkWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterThreadNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            ThreadNetworkDiagnostics::Commands::ResetCounts::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeChannelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRoutingRoleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRoutingRoleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNetworkNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNetworkNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableCharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeExtendedPanIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeExtendedPanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeshLocalPrefixWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeshLocalPrefixWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNeighborTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNeighborTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeRouteTableListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRouteTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsRouteTableListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePartitionIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePartitionIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWeightingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWeightingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStableDataVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStableDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLeaderRouterIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLeaderRouterIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDetachedRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDetachedRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeChildRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeChildRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRouterRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRouterRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLeaderRoleCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLeaderRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartitionIdChangeCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePartitionIdChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBetterPartitionAttachAttemptCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeParentChangeCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeParentChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxAckedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxAckedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxNoAckRequestedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxNoAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxRetryCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxRetryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrCcaCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxErrCcaCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrAbortCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxErrAbortCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrBusyChannelCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxErrBusyChannelCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxTotalCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxUnicastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBroadcastCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDataCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDataPollCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBeaconCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxBeaconRequestCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxAddressFilteredCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxAddressFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDestAddrFilteredCountWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxDestAddrFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxDuplicatedCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxDuplicatedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrNoFrameCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrNoFrameCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrUnknownNeighborCountWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrUnknownNeighborCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrInvalidSrcAddrCountWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrSecCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrSecCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrFcsCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrFcsCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRxErrOtherCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRxErrOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePendingTimestampWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePendingTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDelayWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSecurityPolicyWithCompletion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSecurityPolicyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeChannelPage0MaskWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelPage0Mask::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeChannelPage0MaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationalDatasetComponentsWithCompletion:
    (void (^)(
        MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;
                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge *>(
                    bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)
    readAttributeOperationalDatasetComponentsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(
                                                             MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                             NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeActiveNetworkFaultsListWithCompletion:(void (^)(
                                                               NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;
                chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveNetworkFaultsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThreadNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThreadNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTRThreadNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completion:completionHandler];
}

- (void)readAttributeChannelWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelWithCompletion:completionHandler];
}
- (void)subscribeAttributeChannelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeChannelWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeRoutingRoleWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRoutingRoleWithCompletion:completionHandler];
}
- (void)subscribeAttributeRoutingRoleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRoutingRoleWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeRoutingRoleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRoutingRoleWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeNetworkNameWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeNetworkNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNetworkNameWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeNetworkNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNetworkNameWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributePanIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePanIdWithCompletion:completionHandler];
}
- (void)subscribeAttributePanIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePanIdWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributePanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePanIdWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeExtendedPanIdWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtendedPanIdWithCompletion:completionHandler];
}
- (void)subscribeAttributeExtendedPanIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeExtendedPanIdWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeExtendedPanIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExtendedPanIdWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMeshLocalPrefixWithCompletionHandler:(void (^)(
                                                              NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeshLocalPrefixWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeshLocalPrefixWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeshLocalPrefixWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeshLocalPrefixWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeshLocalPrefixWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeOverrunCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOverrunCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeNeighborTableListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeNeighborTableListWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeNeighborTableListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNeighborTableListWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeNeighborTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeighborTableListWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRouteTableListWithCompletionHandler:(void (^)(
                                                             NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouteTableListWithCompletion:completionHandler];
}
- (void)subscribeAttributeRouteTableListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRouteTableListWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeRouteTableListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouteTableListWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributePartitionIdWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdWithCompletion:completionHandler];
}
- (void)subscribeAttributePartitionIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePartitionIdWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributePartitionIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeWeightingWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWeightingWithCompletion:completionHandler];
}
- (void)subscribeAttributeWeightingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWeightingWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeWeightingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWeightingWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeDataVersionWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeDataVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDataVersionWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDataVersionWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStableDataVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeStableDataVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeStableDataVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStableDataVersionWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeStableDataVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStableDataVersionWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeLeaderRouterIdWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRouterIdWithCompletion:completionHandler];
}
- (void)subscribeAttributeLeaderRouterIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLeaderRouterIdWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeLeaderRouterIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRouterIdWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeDetachedRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeDetachedRoleCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeDetachedRoleCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDetachedRoleCountWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeDetachedRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDetachedRoleCountWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeChildRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeChildRoleCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeChildRoleCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeChildRoleCountWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeChildRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChildRoleCountWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeRouterRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRouterRoleCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRouterRoleCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRouterRoleCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeRouterRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRouterRoleCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeLeaderRoleCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRoleCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeLeaderRoleCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLeaderRoleCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeLeaderRoleCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLeaderRoleCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeAttachAttemptCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttachAttemptCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttachAttemptCountWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttachAttemptCountWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributePartitionIdChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdChangeCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePartitionIdChangeCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePartitionIdChangeCountWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributePartitionIdChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartitionIdChangeCountWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeBetterPartitionAttachAttemptCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeBetterPartitionAttachAttemptCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeBetterPartitionAttachAttemptCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                    params:(MTRSubscribeParams * _Nullable)params
                                                   subscriptionEstablished:
                                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                             reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBetterPartitionAttachAttemptCountWithParams:subscribeParams
                                                subscriptionEstablished:subscriptionEstablishedHandler
                                                          reportHandler:reportHandler];
}
+ (void)readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                       completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeBetterPartitionAttachAttemptCountWithAttributeCache:attributeCacheContainer
                                                                  endpoint:endpoint
                                                                     queue:queue
                                                                completion:completionHandler];
}

- (void)readAttributeParentChangeCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeParentChangeCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeParentChangeCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeParentChangeCountWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeParentChangeCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeParentChangeCountWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeTxTotalCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxTotalCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxTotalCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxTotalCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeTxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxTotalCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeTxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeTxUnicastCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxUnicastCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxUnicastCountWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeTxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxUnicastCountWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeTxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBroadcastCountWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeTxBroadcastCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxBroadcastCountWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeTxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBroadcastCountWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeTxAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckRequestedCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxAckRequestedCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxAckRequestedCountWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeTxAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckRequestedCountWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeTxAckedCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckedCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxAckedCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxAckedCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeTxAckedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxAckedCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeTxNoAckRequestedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeTxNoAckRequestedCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxNoAckRequestedCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxNoAckRequestedCountWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeTxNoAckRequestedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxNoAckRequestedCountWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeTxDataCountWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxDataCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxDataCountWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeTxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataCountWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeTxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataPollCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxDataPollCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxDataPollCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeTxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDataPollCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeTxBeaconCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxBeaconCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxBeaconCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeTxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeTxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconRequestCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxBeaconRequestCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxBeaconRequestCountWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeTxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxBeaconRequestCountWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeTxOtherCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxOtherCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxOtherCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxOtherCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeTxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxOtherCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeTxRetryCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxRetryCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxRetryCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxRetryCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeTxRetryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxRetryCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeTxDirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDirectMaxRetryExpiryCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxDirectMaxRetryExpiryCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxDirectMaxRetryExpiryCountWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeTxDirectMaxRetryExpiryCountWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeTxIndirectMaxRetryExpiryCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeTxIndirectMaxRetryExpiryCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxIndirectMaxRetryExpiryCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxIndirectMaxRetryExpiryCountWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeTxIndirectMaxRetryExpiryCountWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeTxErrCcaCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCcaCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxErrCcaCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxErrCcaCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeTxErrCcaCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCcaCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeTxErrAbortCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrAbortCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxErrAbortCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxErrAbortCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeTxErrAbortCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrAbortCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeTxErrBusyChannelCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrBusyChannelCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxErrBusyChannelCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxErrBusyChannelCountWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeTxErrBusyChannelCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrBusyChannelCountWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeRxTotalCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxTotalCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxTotalCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxTotalCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeRxTotalCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxTotalCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeRxUnicastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeRxUnicastCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxUnicastCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxUnicastCountWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeRxUnicastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxUnicastCountWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeRxBroadcastCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBroadcastCountWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRxBroadcastCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxBroadcastCountWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRxBroadcastCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBroadcastCountWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeRxDataCountWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxDataCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxDataCountWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeRxDataCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataCountWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeRxDataPollCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataPollCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxDataPollCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxDataPollCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeRxDataPollCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDataPollCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeRxBeaconCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxBeaconCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxBeaconCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRxBeaconCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRxBeaconRequestCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconRequestCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxBeaconRequestCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxBeaconRequestCountWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeRxBeaconRequestCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxBeaconRequestCountWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeRxOtherCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxOtherCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxOtherCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxOtherCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeRxOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxOtherCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeRxAddressFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeRxAddressFilteredCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxAddressFilteredCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxAddressFilteredCountWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeRxAddressFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxAddressFilteredCountWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeRxDestAddrFilteredCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDestAddrFilteredCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxDestAddrFilteredCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxDestAddrFilteredCountWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeRxDestAddrFilteredCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDestAddrFilteredCountWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeRxDuplicatedCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDuplicatedCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxDuplicatedCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxDuplicatedCountWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeRxDuplicatedCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxDuplicatedCountWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRxErrNoFrameCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrNoFrameCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrNoFrameCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrNoFrameCountWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeRxErrNoFrameCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrNoFrameCountWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRxErrUnknownNeighborCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrUnknownNeighborCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrUnknownNeighborCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrUnknownNeighborCountWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeRxErrUnknownNeighborCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrUnknownNeighborCountWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeRxErrInvalidSrcAddrCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrInvalidSrcAddrCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrInvalidSrcAddrCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrInvalidSrcAddrCountWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrInvalidSrcAddrCountWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeRxErrSecCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrSecCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrSecCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrSecCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRxErrSecCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrSecCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRxErrFcsCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrFcsCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrFcsCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrFcsCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRxErrFcsCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrFcsCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRxErrOtherCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrOtherCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeRxErrOtherCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRxErrOtherCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeRxErrOtherCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRxErrOtherCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeActiveTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTimestampWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveTimestampWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveTimestampWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeActiveTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveTimestampWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributePendingTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributePendingTimestampWithCompletion:completionHandler];
}
- (void)
    subscribeAttributePendingTimestampWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePendingTimestampWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributePendingTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePendingTimestampWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDelayWithCompletion:completionHandler];
}
- (void)subscribeAttributeDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDelayWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDelayWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeSecurityPolicyWithCompletionHandler:
    (void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityPolicyWithCompletion:completionHandler];
}
- (void)subscribeAttributeSecurityPolicyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                  NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSecurityPolicyWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeSecurityPolicyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:(void (^)(MTRThreadNetworkDiagnosticsClusterSecurityPolicy * _Nullable value,
                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityPolicyWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeChannelPage0MaskWithCompletionHandler:(void (^)(NSData * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelPage0MaskWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeChannelPage0MaskWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeChannelPage0MaskWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeChannelPage0MaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelPage0MaskWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeOperationalDatasetComponentsWithCompletionHandler:
    (void (^)(MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
        NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalDatasetComponentsWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeOperationalDatasetComponentsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:
                                                        (void (^)(
                                                            MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                            NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOperationalDatasetComponentsWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)
    readAttributeOperationalDatasetComponentsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(
                                                      MTRThreadNetworkDiagnosticsClusterOperationalDatasetComponents * _Nullable value,
                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalDatasetComponentsWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeActiveNetworkFaultsListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsListWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveNetworkFaultsListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveNetworkFaultsListWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeActiveNetworkFaultsListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveNetworkFaultsListWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterWiFiNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            WiFiNetworkDiagnostics::Commands::ResetCounts::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeBssidWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBssidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSecurityTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSecurityTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWiFiVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
                chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWiFiVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeChannelNumberWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeChannelNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRssiWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRssiWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                                 completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBeaconLostCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBeaconLostCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBeaconRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBeaconRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketMulticastRxCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketMulticastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketMulticastTxCountWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketMulticastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketUnicastRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketUnicastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketUnicastTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketUnicastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentMaxRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentMaxRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WiFiNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWiFiNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTRWiFiNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completion:completionHandler];
}

- (void)readAttributeBssidWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBssidWithCompletion:completionHandler];
}
- (void)subscribeAttributeBssidWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBssidWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeBssidWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBssidWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeSecurityTypeWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeSecurityTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSecurityTypeWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSecurityTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSecurityTypeWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeWiFiVersionWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiFiVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeWiFiVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWiFiVersionWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeWiFiVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWiFiVersionWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeChannelNumberWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelNumberWithCompletion:completionHandler];
}
- (void)subscribeAttributeChannelNumberWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeChannelNumberWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeChannelNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelNumberWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRssiWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRssiWithCompletion:completionHandler];
}
- (void)subscribeAttributeRssiWithMinInterval:(NSNumber * _Nonnull)minInterval
                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                       params:(MTRSubscribeParams * _Nullable)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRssiWithParams:subscribeParams
                   subscriptionEstablished:subscriptionEstablishedHandler
                             reportHandler:reportHandler];
}
+ (void)readAttributeRssiWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                          completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRssiWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeBeaconLostCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconLostCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeBeaconLostCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBeaconLostCountWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeBeaconLostCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconLostCountWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeBeaconRxCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconRxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeBeaconRxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBeaconRxCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeBeaconRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBeaconRxCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributePacketMulticastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastRxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketMulticastRxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketMulticastRxCountWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributePacketMulticastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastRxCountWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributePacketMulticastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastTxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketMulticastTxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketMulticastTxCountWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributePacketMulticastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketMulticastTxCountWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributePacketUnicastRxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastRxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketUnicastRxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketUnicastRxCountWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributePacketUnicastRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastRxCountWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributePacketUnicastTxCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastTxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketUnicastTxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketUnicastTxCountWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributePacketUnicastTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketUnicastTxCountWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeCurrentMaxRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentMaxRateWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentMaxRateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentMaxRateWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeCurrentMaxRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentMaxRateWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeOverrunCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOverrunCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterEthernetNetworkDiagnostics

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            EthernetNetworkDiagnostics::Commands::ResetCounts::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributePHYRateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
                chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePHYRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFullDuplexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFullDuplexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketRxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePacketTxCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePacketTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTxErrCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTxErrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCollisionCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCollisionCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverrunCountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCarrierDetectWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCarrierDetectWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTimeSinceResetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTimeSinceResetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(EthernetNetworkDiagnosticsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterEthernetNetworkDiagnostics (Deprecated)

- (void)resetCountsWithParams:(MTREthernetNetworkDiagnosticsClusterResetCountsParams * _Nullable)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:params completion:completionHandler];
}
- (void)resetCountsWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self resetCountsWithParams:nil completion:completionHandler];
}

- (void)readAttributePHYRateWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePHYRateWithCompletion:completionHandler];
}
- (void)subscribeAttributePHYRateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePHYRateWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributePHYRateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePHYRateWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeFullDuplexWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFullDuplexWithCompletion:completionHandler];
}
- (void)subscribeAttributeFullDuplexWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFullDuplexWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFullDuplexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFullDuplexWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributePacketRxCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketRxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketRxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketRxCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributePacketRxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketRxCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributePacketTxCountWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketTxCountWithCompletion:completionHandler];
}
- (void)subscribeAttributePacketTxCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePacketTxCountWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributePacketTxCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePacketTxCountWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeTxErrCountWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeTxErrCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTxErrCountWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeTxErrCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTxErrCountWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeCollisionCountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeCollisionCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeCollisionCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCollisionCountWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeCollisionCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCollisionCountWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeOverrunCountWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithCompletion:completionHandler];
}
- (void)subscribeAttributeOverrunCountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOverrunCountWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeOverrunCountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverrunCountWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeCarrierDetectWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCarrierDetectWithCompletion:completionHandler];
}
- (void)subscribeAttributeCarrierDetectWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCarrierDetectWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeCarrierDetectWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCarrierDetectWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeTimeSinceResetWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeTimeSinceResetWithCompletion:completionHandler];
}
- (void)subscribeAttributeTimeSinceResetWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTimeSinceResetWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeTimeSinceResetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimeSinceResetWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBridgedDeviceBasic

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

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

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNodeLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::NodeLabel::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHardwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoftwareVersionStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeManufacturingDateWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePartNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductURLWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductLabelWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSerialNumberWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReachableWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUniqueIDWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BridgedDeviceBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BridgedDeviceBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BridgedDeviceBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BridgedDeviceBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBridgedDeviceBasic (Deprecated)

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorNameWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorIDWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeProductNameWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductNameWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeProductNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductNameWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeNodeLabelWithCompletionHandler:(void (^)(
                                                        NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithCompletion:completionHandler];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNodeLabelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNodeLabelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNodeLabelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNodeLabelWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeNodeLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNodeLabelWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeHardwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeHardwareVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHardwareVersionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeHardwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeHardwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithCompletion:completionHandler];
}
- (void)subscribeAttributeHardwareVersionStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHardwareVersionStringWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeHardwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeHardwareVersionStringWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeSoftwareVersionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeSoftwareVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSoftwareVersionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeSoftwareVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeSoftwareVersionStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithCompletion:completionHandler];
}
- (void)subscribeAttributeSoftwareVersionStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSoftwareVersionStringWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeSoftwareVersionStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoftwareVersionStringWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeManufacturingDateWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithCompletion:completionHandler];
}
- (void)subscribeAttributeManufacturingDateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeManufacturingDateWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeManufacturingDateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeManufacturingDateWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePartNumberWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithCompletion:completionHandler];
}
- (void)subscribeAttributePartNumberWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePartNumberWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributePartNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePartNumberWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeProductURLWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductURLWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductURLWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeProductURLWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductURLWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeProductLabelWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductLabelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductLabelWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeProductLabelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductLabelWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSerialNumberWithCompletionHandler:(void (^)(
                                                           NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithCompletion:completionHandler];
}
- (void)subscribeAttributeSerialNumberWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSerialNumberWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSerialNumberWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSerialNumberWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeReachableWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithCompletion:completionHandler];
}
- (void)subscribeAttributeReachableWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReachableWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeReachableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReachableWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeUniqueIDWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeUniqueIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUniqueIDWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeUniqueIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUniqueIDWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterSwitch

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

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

- (void)readAttributeNumberOfPositionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfPositionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMultiPressMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMultiPressMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(SwitchGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(SwitchAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, SwitchAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, SwitchAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::AttributeList::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRSwitchAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(SwitchAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::SwitchCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterSwitch (Deprecated)

- (void)readAttributeNumberOfPositionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPositionsWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfPositionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfPositionsWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfPositionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPositionsWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeCurrentPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeMultiPressMaxWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMultiPressMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeMultiPressMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMultiPressMaxWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMultiPressMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMultiPressMaxWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterAdministratorCommissioning

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

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

- (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenCommissioningWindowParams *)params
                               completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeWindowStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
                chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge *>(
                    bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWindowStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAdminFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAdminFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAdminVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAdminVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AdministratorCommissioningGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AdministratorCommissioningAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AdministratorCommissioningAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::AdministratorCommissioningCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAdministratorCommissioning (Deprecated)

- (void)openCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenCommissioningWindowParams *)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self openCommissioningWindowWithParams:params completion:completionHandler];
}
- (void)openBasicCommissioningWindowWithParams:(MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams *)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self openBasicCommissioningWindowWithParams:params completion:completionHandler];
}
- (void)revokeCommissioningWithParams:(MTRAdministratorCommissioningClusterRevokeCommissioningParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self revokeCommissioningWithParams:params completion:completionHandler];
}
- (void)revokeCommissioningWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self revokeCommissioningWithParams:nil completion:completionHandler];
}

- (void)readAttributeWindowStatusWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindowStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeWindowStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWindowStatusWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeWindowStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindowStatusWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeAdminFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminFabricIndexWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeAdminFabricIndexWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAdminFabricIndexWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeAdminFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminFabricIndexWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeAdminVendorIdWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminVendorIdWithCompletion:completionHandler];
}
- (void)subscribeAttributeAdminVendorIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAdminVendorIdWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAdminVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAdminVendorIdWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOperationalCredentials

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTROperationalCredentialsClusterAttestationResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterAttestationResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterCertificateChainResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterCSRResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterCSRResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsClusterNOCResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsClusterNOCResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::NOCs::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNOCsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                                 completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsNOCsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, 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];
    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::Fabrics::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsFabricsListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCommissionedFabricsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCommissionedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTrustedRootCertificatesWithCompletion:(void (^)(
                                                               NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTrustedRootCertificatesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsTrustedRootCertificatesListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentFabricIndexWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::AttributeList::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OperationalCredentialsAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OperationalCredentialsCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOperationalCredentials (Deprecated)

- (void)attestationRequestWithParams:(MTROperationalCredentialsClusterAttestationRequestParams *)params
                   completionHandler:(void (^)(MTROperationalCredentialsClusterAttestationResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self attestationRequestWithParams:params completion:completionHandler];
}
- (void)certificateChainRequestWithParams:(MTROperationalCredentialsClusterCertificateChainRequestParams *)params
                        completionHandler:(void (^)(MTROperationalCredentialsClusterCertificateChainResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    [self certificateChainRequestWithParams:params completion:completionHandler];
}
- (void)CSRRequestWithParams:(MTROperationalCredentialsClusterCSRRequestParams *)params
           completionHandler:(void (^)(MTROperationalCredentialsClusterCSRResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    [self CSRRequestWithParams:params completion:completionHandler];
}
- (void)addNOCWithParams:(MTROperationalCredentialsClusterAddNOCParams *)params
       completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                             NSError * _Nullable error))completionHandler
{
    [self addNOCWithParams:params completion:completionHandler];
}
- (void)updateNOCWithParams:(MTROperationalCredentialsClusterUpdateNOCParams *)params
          completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                NSError * _Nullable error))completionHandler
{
    [self updateNOCWithParams:params completion:completionHandler];
}
- (void)updateFabricLabelWithParams:(MTROperationalCredentialsClusterUpdateFabricLabelParams *)params
                  completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    [self updateFabricLabelWithParams:params completion:completionHandler];
}
- (void)removeFabricWithParams:(MTROperationalCredentialsClusterRemoveFabricParams *)params
             completionHandler:(void (^)(MTROperationalCredentialsClusterNOCResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self removeFabricWithParams:params completion:completionHandler];
}
- (void)addTrustedRootCertificateWithParams:(MTROperationalCredentialsClusterAddTrustedRootCertificateParams *)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self addTrustedRootCertificateWithParams:params completion:completionHandler];
}

- (void)readAttributeNOCsWithParams:(MTRReadParams * _Nullable)params
                  completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNOCsWithParams:params completion:completionHandler];
}
- (void)subscribeAttributeNOCsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                       params:(MTRSubscribeParams * _Nullable)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNOCsWithParams:subscribeParams
                   subscriptionEstablished:subscriptionEstablishedHandler
                             reportHandler:reportHandler];
}
+ (void)readAttributeNOCsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                          completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNOCsWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeFabricsWithParams:(MTRReadParams * _Nullable)params
                     completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFabricsWithParams:params completion:completionHandler];
}
- (void)subscribeAttributeFabricsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFabricsWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFabricsWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeSupportedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedFabricsWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeSupportedFabricsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedFabricsWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeSupportedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedFabricsWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeCommissionedFabricsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeCommissionedFabricsWithCompletion:completionHandler];
}
- (void)subscribeAttributeCommissionedFabricsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCommissionedFabricsWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeCommissionedFabricsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCommissionedFabricsWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeTrustedRootCertificatesWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeTrustedRootCertificatesWithCompletion:completionHandler];
}
- (void)subscribeAttributeTrustedRootCertificatesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:
                                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTrustedRootCertificatesWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeTrustedRootCertificatesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTrustedRootCertificatesWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeCurrentFabricIndexWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFabricIndexWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentFabricIndexWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentFabricIndexWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeCurrentFabricIndexWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentFabricIndexWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterGroupKeyManagement

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

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

- (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementClusterKeySetReadResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGroupKeyMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupKeyManagementGroupKeyMapListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, 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];
    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGroupTableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupKeyManagementGroupTableListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeMaxGroupsPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxGroupsPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxGroupKeysPerFabricWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxGroupKeysPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupKeyManagementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupKeyManagementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(GroupKeyManagementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::GroupKeyManagementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterGroupKeyManagement (Deprecated)

- (void)keySetWriteWithParams:(MTRGroupKeyManagementClusterKeySetWriteParams *)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self keySetWriteWithParams:params completion:completionHandler];
}
- (void)keySetReadWithParams:(MTRGroupKeyManagementClusterKeySetReadParams *)params
           completionHandler:(void (^)(MTRGroupKeyManagementClusterKeySetReadResponseParams * _Nullable data,
                                 NSError * _Nullable error))completionHandler
{
    [self keySetReadWithParams:params completion:completionHandler];
}
- (void)keySetRemoveWithParams:(MTRGroupKeyManagementClusterKeySetRemoveParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self keySetRemoveWithParams:params completion:completionHandler];
}
- (void)keySetReadAllIndicesWithParams:(MTRGroupKeyManagementClusterKeySetReadAllIndicesParams *)params
                     completionHandler:(void (^)(MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    [self keySetReadAllIndicesWithParams:params completion:completionHandler];
}

- (void)readAttributeGroupKeyMapWithParams:(MTRReadParams * _Nullable)params
                         completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupKeyMapWithParams:params completion:completionHandler];
}
- (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeGroupKeyMapWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeGroupKeyMapWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeGroupKeyMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGroupKeyMapWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeGroupKeyMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupKeyMapWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeGroupTableWithParams:(MTRReadParams * _Nullable)params
                        completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupTableWithParams:params completion:completionHandler];
}
- (void)subscribeAttributeGroupTableWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGroupTableWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeGroupTableWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGroupTableWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeMaxGroupsPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupsPerFabricWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxGroupsPerFabricWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxGroupsPerFabricWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeMaxGroupsPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupsPerFabricWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeMaxGroupKeysPerFabricWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupKeysPerFabricWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxGroupKeysPerFabricWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxGroupKeysPerFabricWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeMaxGroupKeysPerFabricWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxGroupKeysPerFabricWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterFixedLabel

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

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

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelLabelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelLabelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::LabelList::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelLabelListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FixedLabelLabelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FixedLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FixedLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FixedLabelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::AttributeList::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FixedLabelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::FixedLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFixedLabel (Deprecated)

- (void)readAttributeLabelListWithCompletionHandler:(void (^)(
                                                        NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithCompletion:completionHandler];
}
- (void)subscribeAttributeLabelListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLabelListWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterUserLabel

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

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

- (void)readAttributeLabelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelLabelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelLabelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelLabelListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(UserLabelLabelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UserLabelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(UserLabelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, UserLabelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::AttributeList::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRUserLabelAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(UserLabelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::UserLabelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterUserLabel (Deprecated)

- (void)readAttributeLabelListWithCompletionHandler:(void (^)(
                                                        NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithCompletion:completionHandler];
}
- (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLabelListWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLabelListWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLabelListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLabelListWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeLabelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLabelListWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBooleanState

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

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

- (void)readAttributeStateValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStateValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BooleanStateGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BooleanStateAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::AttributeList::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanStateAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BooleanStateCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBooleanState (Deprecated)

- (void)readAttributeStateValueWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStateValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeStateValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStateValueWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeStateValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStateValueWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterModeSelect

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

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

- (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeDescriptionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStandardNamespaceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStandardNamespaceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSupportedModesWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectSupportedModesListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectSupportedModesListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::SupportedModes::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ModeSelectSupportedModesListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartUpModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOnModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOnModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ModeSelectGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ModeSelectAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ModeSelectAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::AttributeList::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRModeSelectAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ModeSelectAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ModeSelectCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterModeSelect (Deprecated)

- (void)changeToModeWithParams:(MTRModeSelectClusterChangeToModeParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self changeToModeWithParams:params completion:completionHandler];
}

- (void)readAttributeDescriptionWithCompletionHandler:(void (^)(
                                                          NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithCompletion:completionHandler];
}
- (void)subscribeAttributeDescriptionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDescriptionWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeDescriptionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDescriptionWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStandardNamespaceWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeStandardNamespaceWithCompletion:completionHandler];
}
- (void)subscribeAttributeStandardNamespaceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStandardNamespaceWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeStandardNamespaceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStandardNamespaceWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeSupportedModesWithCompletionHandler:(void (^)(
                                                             NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedModesWithCompletion:completionHandler];
}
- (void)subscribeAttributeSupportedModesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedModesWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeSupportedModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedModesWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeCurrentModeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentModeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeCurrentModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentModeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStartUpModeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpModeWithCompletion:completionHandler];
}
- (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeStartUpModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartUpModeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeStartUpModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpModeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeOnModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnModeWithCompletion:completionHandler];
}
- (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOnModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOnModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOnModeWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeOnModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOnModeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterDoorLock

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

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

- (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];
                }
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];
                }
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterGetWeekDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterGetYearDayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterGetHolidayScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterGetUserResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterGetUserResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterSetCredentialResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterSetCredentialResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterGetCredentialStatusResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeLockStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLockStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableDoorLockClusterDlLockStateAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLockTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterDlLockTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockClusterDlLockTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLockTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DoorLockClusterDlLockTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActuatorEnabledWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActuatorEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDoorStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDoorStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableDoorLockClusterDlDoorStateAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeDoorOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDoorOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDoorClosedEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDoorClosedEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfTotalUsersSupportedWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfTotalUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfPINUsersSupportedWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfPINUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfRFIDUsersSupportedWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinPINCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinRFIDCodeLengthWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCredentialRulesSupportWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCredentialRulesSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockCredentialRulesSupportAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLanguageWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLanguageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLEDSettingsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLEDSettingsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAutoRelockTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAutoRelockTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSoundVolumeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSoundVolumeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperatingModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOperatingModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockClusterDlOperatingModeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedOperatingModesWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedOperatingModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockSupportedOperatingModesAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeDefaultConfigurationRegisterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDefaultConfigurationRegisterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockDefaultConfigurationRegisterAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEnableLocalProgrammingWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnableLocalProgrammingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnableOneTouchLockingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnableOneTouchLockingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnableInsideStatusLEDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnableInsideStatusLEDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnablePrivacyModeButtonWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnablePrivacyModeButtonWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalProgrammingFeaturesWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocalProgrammingFeaturesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockLocalProgrammingFeaturesAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeWrongCodeEntryLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWrongCodeEntryLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUserCodeTemporaryDisableTimeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSendPINOverTheAirWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSendPINOverTheAirWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRequirePINforRemoteOperationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRequirePINforRemoteOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeExpiringUserTimeoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeExpiringUserTimeoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(DoorLockAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoorLockAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::AttributeList::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoorLockAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DoorLockAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::DoorLockCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterDoorLock (Deprecated)

- (void)lockDoorWithParams:(MTRDoorLockClusterLockDoorParams * _Nullable)params
         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self lockDoorWithParams:params completion:completionHandler];
}
- (void)unlockDoorWithParams:(MTRDoorLockClusterUnlockDoorParams * _Nullable)params
           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self unlockDoorWithParams:params completion:completionHandler];
}
- (void)unlockWithTimeoutWithParams:(MTRDoorLockClusterUnlockWithTimeoutParams *)params
                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self unlockWithTimeoutWithParams:params completion:completionHandler];
}
- (void)setWeekDayScheduleWithParams:(MTRDoorLockClusterSetWeekDayScheduleParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setWeekDayScheduleWithParams:params completion:completionHandler];
}
- (void)getWeekDayScheduleWithParams:(MTRDoorLockClusterGetWeekDayScheduleParams *)params
                   completionHandler:(void (^)(MTRDoorLockClusterGetWeekDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self getWeekDayScheduleWithParams:params completion:completionHandler];
}
- (void)clearWeekDayScheduleWithParams:(MTRDoorLockClusterClearWeekDayScheduleParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearWeekDayScheduleWithParams:params completion:completionHandler];
}
- (void)setYearDayScheduleWithParams:(MTRDoorLockClusterSetYearDayScheduleParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setYearDayScheduleWithParams:params completion:completionHandler];
}
- (void)getYearDayScheduleWithParams:(MTRDoorLockClusterGetYearDayScheduleParams *)params
                   completionHandler:(void (^)(MTRDoorLockClusterGetYearDayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self getYearDayScheduleWithParams:params completion:completionHandler];
}
- (void)clearYearDayScheduleWithParams:(MTRDoorLockClusterClearYearDayScheduleParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearYearDayScheduleWithParams:params completion:completionHandler];
}
- (void)setHolidayScheduleWithParams:(MTRDoorLockClusterSetHolidayScheduleParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setHolidayScheduleWithParams:params completion:completionHandler];
}
- (void)getHolidayScheduleWithParams:(MTRDoorLockClusterGetHolidayScheduleParams *)params
                   completionHandler:(void (^)(MTRDoorLockClusterGetHolidayScheduleResponseParams * _Nullable data,
                                         NSError * _Nullable error))completionHandler
{
    [self getHolidayScheduleWithParams:params completion:completionHandler];
}
- (void)clearHolidayScheduleWithParams:(MTRDoorLockClusterClearHolidayScheduleParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearHolidayScheduleWithParams:params completion:completionHandler];
}
- (void)setUserWithParams:(MTRDoorLockClusterSetUserParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setUserWithParams:params completion:completionHandler];
}
- (void)getUserWithParams:(MTRDoorLockClusterGetUserParams *)params
        completionHandler:
            (void (^)(MTRDoorLockClusterGetUserResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self getUserWithParams:params completion:completionHandler];
}
- (void)clearUserWithParams:(MTRDoorLockClusterClearUserParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearUserWithParams:params completion:completionHandler];
}
- (void)setCredentialWithParams:(MTRDoorLockClusterSetCredentialParams *)params
              completionHandler:(void (^)(MTRDoorLockClusterSetCredentialResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    [self setCredentialWithParams:params completion:completionHandler];
}
- (void)getCredentialStatusWithParams:(MTRDoorLockClusterGetCredentialStatusParams *)params
                    completionHandler:(void (^)(MTRDoorLockClusterGetCredentialStatusResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    [self getCredentialStatusWithParams:params completion:completionHandler];
}
- (void)clearCredentialWithParams:(MTRDoorLockClusterClearCredentialParams *)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearCredentialWithParams:params completion:completionHandler];
}

- (void)readAttributeLockStateWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeLockStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLockStateWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeLockStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockStateWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeLockTypeWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeLockTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLockTypeWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeLockTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLockTypeWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeActuatorEnabledWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeActuatorEnabledWithCompletion:completionHandler];
}
- (void)subscribeAttributeActuatorEnabledWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActuatorEnabledWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeActuatorEnabledWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActuatorEnabledWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeDoorStateWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeDoorStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDoorStateWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeDoorStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorStateWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeDoorOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorOpenEventsWithCompletion:completionHandler];
}
- (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDoorOpenEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDoorOpenEventsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeDoorOpenEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDoorOpenEventsWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeDoorOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorOpenEventsWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeDoorClosedEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorClosedEventsWithCompletion:completionHandler];
}
- (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDoorClosedEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeDoorClosedEventsWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeDoorClosedEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDoorClosedEventsWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeDoorClosedEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDoorClosedEventsWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeOpenPeriodWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOpenPeriodWithCompletion:completionHandler];
}
- (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOpenPeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOpenPeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOpenPeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOpenPeriodWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOpenPeriodWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeNumberOfTotalUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfTotalUsersSupportedWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfTotalUsersSupportedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfTotalUsersSupportedWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfTotalUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfTotalUsersSupportedWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeNumberOfPINUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPINUsersSupportedWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfPINUsersSupportedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfPINUsersSupportedWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfPINUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPINUsersSupportedWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeNumberOfRFIDUsersSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfRFIDUsersSupportedWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfRFIDUsersSupportedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfRFIDUsersSupportedWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfRFIDUsersSupportedWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeekDaySchedulesSupportedPerUserWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfYearDaySchedulesSupportedPerUserWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfYearDaySchedulesSupportedPerUserWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfYearDaySchedulesSupportedPerUserWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributeNumberOfHolidaySchedulesSupportedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfHolidaySchedulesSupportedWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfHolidaySchedulesSupportedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                    params:(MTRSubscribeParams * _Nullable)params
                                                   subscriptionEstablished:
                                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                             reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfHolidaySchedulesSupportedWithParams:subscribeParams
                                                subscriptionEstablished:subscriptionEstablishedHandler
                                                          reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                       completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfHolidaySchedulesSupportedWithAttributeCache:attributeCacheContainer
                                                                  endpoint:endpoint
                                                                     queue:queue
                                                                completion:completionHandler];
}

- (void)readAttributeMaxPINCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPINCodeLengthWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxPINCodeLengthWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxPINCodeLengthWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPINCodeLengthWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMinPINCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinPINCodeLengthWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinPINCodeLengthWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinPINCodeLengthWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinPINCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinPINCodeLengthWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxRFIDCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxRFIDCodeLengthWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxRFIDCodeLengthWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxRFIDCodeLengthWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeMaxRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxRFIDCodeLengthWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeMinRFIDCodeLengthWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeMinRFIDCodeLengthWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinRFIDCodeLengthWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinRFIDCodeLengthWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeMinRFIDCodeLengthWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinRFIDCodeLengthWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeCredentialRulesSupportWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeCredentialRulesSupportWithCompletion:completionHandler];
}
- (void)subscribeAttributeCredentialRulesSupportWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCredentialRulesSupportWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeCredentialRulesSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCredentialRulesSupportWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeNumberOfCredentialsSupportedPerUserWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfCredentialsSupportedPerUserWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfCredentialsSupportedPerUserWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                      params:(MTRSubscribeParams * _Nullable)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfCredentialsSupportedPerUserWithParams:subscribeParams
                                                  subscriptionEstablished:subscriptionEstablishedHandler
                                                            reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                         completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfCredentialsSupportedPerUserWithAttributeCache:attributeCacheContainer
                                                                    endpoint:endpoint
                                                                       queue:queue
                                                                  completion:completionHandler];
}

- (void)readAttributeLanguageWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLanguageWithCompletion:completionHandler];
}
- (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLanguageWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLanguageWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLanguageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLanguageWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeLanguageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLanguageWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeLEDSettingsWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLEDSettingsWithCompletion:completionHandler];
}
- (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLEDSettingsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLEDSettingsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLEDSettingsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLEDSettingsWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeLEDSettingsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLEDSettingsWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeAutoRelockTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeAutoRelockTimeWithCompletion:completionHandler];
}
- (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAutoRelockTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAutoRelockTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeAutoRelockTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAutoRelockTimeWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeAutoRelockTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAutoRelockTimeWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeSoundVolumeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoundVolumeWithCompletion:completionHandler];
}
- (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSoundVolumeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSoundVolumeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSoundVolumeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSoundVolumeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeSoundVolumeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSoundVolumeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeOperatingModeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperatingModeWithCompletion:completionHandler];
}
- (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOperatingModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOperatingModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOperatingModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOperatingModeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeOperatingModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperatingModeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeSupportedOperatingModesWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedOperatingModesWithCompletion:completionHandler];
}
- (void)subscribeAttributeSupportedOperatingModesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedOperatingModesWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeSupportedOperatingModesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedOperatingModesWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeDefaultConfigurationRegisterWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultConfigurationRegisterWithCompletion:completionHandler];
}
- (void)subscribeAttributeDefaultConfigurationRegisterWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDefaultConfigurationRegisterWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeDefaultConfigurationRegisterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeDefaultConfigurationRegisterWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeEnableLocalProgrammingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableLocalProgrammingWithCompletion:completionHandler];
}
- (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableLocalProgrammingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value
                                               params:(MTRWriteParams * _Nullable)params
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableLocalProgrammingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnableLocalProgrammingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnableLocalProgrammingWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeEnableLocalProgrammingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableLocalProgrammingWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeEnableOneTouchLockingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableOneTouchLockingWithCompletion:completionHandler];
}
- (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableOneTouchLockingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableOneTouchLockingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnableOneTouchLockingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnableOneTouchLockingWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeEnableOneTouchLockingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableOneTouchLockingWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeEnableInsideStatusLEDWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableInsideStatusLEDWithCompletion:completionHandler];
}
- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableInsideStatusLEDWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnableInsideStatusLEDWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnableInsideStatusLEDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnableInsideStatusLEDWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeEnableInsideStatusLEDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnableInsideStatusLEDWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeEnablePrivacyModeButtonWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeEnablePrivacyModeButtonWithCompletion:completionHandler];
}
- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnablePrivacyModeButtonWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnablePrivacyModeButtonWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnablePrivacyModeButtonWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnablePrivacyModeButtonWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeEnablePrivacyModeButtonWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnablePrivacyModeButtonWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeLocalProgrammingFeaturesWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalProgrammingFeaturesWithCompletion:completionHandler];
}
- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalProgrammingFeaturesWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)value
                                                 params:(MTRWriteParams * _Nullable)params
                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalProgrammingFeaturesWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLocalProgrammingFeaturesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocalProgrammingFeaturesWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeLocalProgrammingFeaturesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalProgrammingFeaturesWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeWrongCodeEntryLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeWrongCodeEntryLimitWithCompletion:completionHandler];
}
- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWrongCodeEntryLimitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWrongCodeEntryLimitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeWrongCodeEntryLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWrongCodeEntryLimitWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeWrongCodeEntryLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWrongCodeEntryLimitWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeUserCodeTemporaryDisableTimeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeUserCodeTemporaryDisableTimeWithCompletion:completionHandler];
}
- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUserCodeTemporaryDisableTimeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUserCodeTemporaryDisableTimeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUserCodeTemporaryDisableTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUserCodeTemporaryDisableTimeWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeUserCodeTemporaryDisableTimeWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeSendPINOverTheAirWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeSendPINOverTheAirWithCompletion:completionHandler];
}
- (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSendPINOverTheAirWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSendPINOverTheAirWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSendPINOverTheAirWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSendPINOverTheAirWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeSendPINOverTheAirWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSendPINOverTheAirWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRequirePINforRemoteOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeRequirePINforRemoteOperationWithCompletion:completionHandler];
}
- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRequirePINforRemoteOperationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRequirePINforRemoteOperationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRequirePINforRemoteOperationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRequirePINforRemoteOperationWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeRequirePINforRemoteOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeRequirePINforRemoteOperationWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeExpiringUserTimeoutWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeExpiringUserTimeoutWithCompletion:completionHandler];
}
- (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeExpiringUserTimeoutWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeExpiringUserTimeoutWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeExpiringUserTimeoutWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeExpiringUserTimeoutWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeExpiringUserTimeoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeExpiringUserTimeoutWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterWindowCovering

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            WindowCovering::Commands::UpOrOpen::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            WindowCovering::Commands::DownOrClose::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            WindowCovering::Commands::StopMotion::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringClusterTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringClusterTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                                 completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(WindowCoveringClusterTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalClosedLimitLiftWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalClosedLimitTiltWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionLiftWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfActuationsLiftWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfActuationsLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfActuationsTiltWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfActuationsTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeConfigStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringConfigStatusAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringConfigStatusAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeConfigStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(WindowCoveringConfigStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionLiftPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionLiftPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltPercentageWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionTiltPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationalStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOperationalStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WindowCoveringOperationalStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeTargetPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTargetPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTargetPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTargetPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEndProductTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEndProductTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WindowCoveringClusterEndProductTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentPositionLiftPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentPositionTiltPercent100thsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledOpenLimitLiftWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstalledOpenLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledClosedLimitLiftWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstalledClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledOpenLimitTiltWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstalledOpenLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstalledClosedLimitTiltWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstalledClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringModeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringModeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringModeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                                 completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(WindowCoveringModeAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringSafetyStatusAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WindowCoveringSafetyStatusAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(WindowCoveringSafetyStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WindowCoveringGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WindowCoveringAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::AttributeList::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WindowCoveringAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::WindowCoveringCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWindowCovering (Deprecated)

- (void)upOrOpenWithParams:(MTRWindowCoveringClusterUpOrOpenParams * _Nullable)params
         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self upOrOpenWithParams:params completion:completionHandler];
}
- (void)upOrOpenWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self upOrOpenWithParams:nil completion:completionHandler];
}
- (void)downOrCloseWithParams:(MTRWindowCoveringClusterDownOrCloseParams * _Nullable)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self downOrCloseWithParams:params completion:completionHandler];
}
- (void)downOrCloseWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self downOrCloseWithParams:nil completion:completionHandler];
}
- (void)stopMotionWithParams:(MTRWindowCoveringClusterStopMotionParams * _Nullable)params
           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopMotionWithParams:params completion:completionHandler];
}
- (void)stopMotionWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopMotionWithParams:nil completion:completionHandler];
}
- (void)goToLiftValueWithParams:(MTRWindowCoveringClusterGoToLiftValueParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self goToLiftValueWithParams:params completion:completionHandler];
}
- (void)goToLiftPercentageWithParams:(MTRWindowCoveringClusterGoToLiftPercentageParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self goToLiftPercentageWithParams:params completion:completionHandler];
}
- (void)goToTiltValueWithParams:(MTRWindowCoveringClusterGoToTiltValueParams *)params
              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self goToTiltValueWithParams:params completion:completionHandler];
}
- (void)goToTiltPercentageWithParams:(MTRWindowCoveringClusterGoToTiltPercentageParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self goToTiltPercentageWithParams:params completion:completionHandler];
}

- (void)readAttributeTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                       params:(MTRSubscribeParams * _Nullable)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTypeWithParams:subscribeParams
                   subscriptionEstablished:subscriptionEstablishedHandler
                             reportHandler:reportHandler];
}
+ (void)readAttributeTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                          completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTypeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributePhysicalClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitLiftWithCompletion:completionHandler];
}
- (void)subscribeAttributePhysicalClosedLimitLiftWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalClosedLimitLiftWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributePhysicalClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitLiftWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributePhysicalClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitTiltWithCompletion:completionHandler];
}
- (void)subscribeAttributePhysicalClosedLimitTiltWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalClosedLimitTiltWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributePhysicalClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalClosedLimitTiltWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeCurrentPositionLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionLiftWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionLiftWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeCurrentPositionTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionTiltWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionTiltWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeNumberOfActuationsLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsLiftWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfActuationsLiftWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfActuationsLiftWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfActuationsLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsLiftWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeNumberOfActuationsTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsTiltWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfActuationsTiltWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfActuationsTiltWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfActuationsTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfActuationsTiltWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeConfigStatusWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConfigStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeConfigStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeConfigStatusWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeConfigStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeConfigStatusWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeCurrentPositionLiftPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercentageWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionLiftPercentageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionLiftPercentageWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionLiftPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercentageWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeCurrentPositionTiltPercentageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercentageWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionTiltPercentageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionTiltPercentageWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionTiltPercentageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercentageWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeOperationalStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeOperationalStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOperationalStatusWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeOperationalStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationalStatusWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeTargetPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionLiftPercent100thsWithCompletion:completionHandler];
}
- (void)subscribeAttributeTargetPositionLiftPercent100thsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTargetPositionLiftPercent100thsWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeTargetPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionLiftPercent100thsWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeTargetPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionTiltPercent100thsWithCompletion:completionHandler];
}
- (void)subscribeAttributeTargetPositionTiltPercent100thsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTargetPositionTiltPercent100thsWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeTargetPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetPositionTiltPercent100thsWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeEndProductTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeEndProductTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeEndProductTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEndProductTypeWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeEndProductTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEndProductTypeWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeCurrentPositionLiftPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercent100thsWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionLiftPercent100thsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                              maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                   params:(MTRSubscribeParams * _Nullable)params
                                                  subscriptionEstablished:
                                                      (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                            reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionLiftPercent100thsWithParams:subscribeParams
                                               subscriptionEstablished:subscriptionEstablishedHandler
                                                         reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                      completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionLiftPercent100thsWithAttributeCache:attributeCacheContainer
                                                                 endpoint:endpoint
                                                                    queue:queue
                                                               completion:completionHandler];
}

- (void)readAttributeCurrentPositionTiltPercent100thsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercent100thsWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentPositionTiltPercent100thsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                              maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                   params:(MTRSubscribeParams * _Nullable)params
                                                  subscriptionEstablished:
                                                      (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                            reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentPositionTiltPercent100thsWithParams:subscribeParams
                                               subscriptionEstablished:subscriptionEstablishedHandler
                                                         reportHandler:reportHandler];
}
+ (void)readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                      completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentPositionTiltPercent100thsWithAttributeCache:attributeCacheContainer
                                                                 endpoint:endpoint
                                                                    queue:queue
                                                               completion:completionHandler];
}

- (void)readAttributeInstalledOpenLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitLiftWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstalledOpenLimitLiftWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstalledOpenLimitLiftWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeInstalledOpenLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitLiftWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeInstalledClosedLimitLiftWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitLiftWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstalledClosedLimitLiftWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstalledClosedLimitLiftWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeInstalledClosedLimitLiftWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitLiftWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeInstalledOpenLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitTiltWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstalledOpenLimitTiltWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstalledOpenLimitTiltWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeInstalledOpenLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledOpenLimitTiltWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeInstalledClosedLimitTiltWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitTiltWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstalledClosedLimitTiltWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstalledClosedLimitTiltWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeInstalledClosedLimitTiltWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstalledClosedLimitTiltWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeModeWithCompletion:completionHandler];
}
- (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value
                             params:(MTRWriteParams * _Nullable)params
                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                       params:(MTRSubscribeParams * _Nullable)params
                      subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeModeWithParams:subscribeParams
                   subscriptionEstablished:subscriptionEstablishedHandler
                             reportHandler:reportHandler];
}
+ (void)readAttributeModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                   endpoint:(NSNumber *)endpoint
                                      queue:(dispatch_queue_t)queue
                          completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeModeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeSafetyStatusWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSafetyStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeSafetyStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSafetyStatusWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSafetyStatusWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBarrierControl

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

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

- (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierControlGoToPercentParams *)params
                                 completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            BarrierControl::Commands::BarrierControlStop::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeBarrierMovingStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierMovingStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierSafetyStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierOpenEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCloseEventsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCommandOpenEventsWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierCommandOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierCommandCloseEventsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierCommandCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierOpenPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierClosePeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierClosePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBarrierPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBarrierPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BarrierControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BarrierControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BarrierControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BarrierControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBarrierControl (Deprecated)

- (void)barrierControlGoToPercentWithParams:(MTRBarrierControlClusterBarrierControlGoToPercentParams *)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self barrierControlGoToPercentWithParams:params completion:completionHandler];
}
- (void)barrierControlStopWithParams:(MTRBarrierControlClusterBarrierControlStopParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self barrierControlStopWithParams:params completion:completionHandler];
}
- (void)barrierControlStopWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self barrierControlStopWithParams:nil completion:completionHandler];
}

- (void)readAttributeBarrierMovingStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierMovingStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeBarrierMovingStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierMovingStateWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeBarrierMovingStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierMovingStateWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeBarrierSafetyStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierSafetyStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeBarrierSafetyStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierSafetyStatusWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeBarrierSafetyStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierSafetyStatusWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeBarrierCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCapabilitiesWithCompletion:completionHandler];
}
- (void)subscribeAttributeBarrierCapabilitiesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierCapabilitiesWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeBarrierCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCapabilitiesWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeBarrierOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenEventsWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierOpenEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierOpenEventsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierOpenEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierOpenEventsWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeBarrierOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenEventsWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeBarrierCloseEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCloseEventsWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCloseEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCloseEventsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierCloseEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierCloseEventsWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeBarrierCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCloseEventsWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeBarrierCommandOpenEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandOpenEventsWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCommandOpenEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)value
                                                 params:(MTRWriteParams * _Nullable)params
                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCommandOpenEventsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierCommandOpenEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierCommandOpenEventsWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeBarrierCommandOpenEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandOpenEventsWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeBarrierCommandCloseEventsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandCloseEventsWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCommandCloseEventsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierCommandCloseEventsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierCommandCloseEventsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierCommandCloseEventsWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeBarrierCommandCloseEventsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierCommandCloseEventsWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeBarrierOpenPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenPeriodWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierOpenPeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierOpenPeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierOpenPeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierOpenPeriodWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeBarrierOpenPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierOpenPeriodWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeBarrierClosePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierClosePeriodWithCompletion:completionHandler];
}
- (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierClosePeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBarrierClosePeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBarrierClosePeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierClosePeriodWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeBarrierClosePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierClosePeriodWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeBarrierPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierPositionWithCompletion:completionHandler];
}
- (void)subscribeAttributeBarrierPositionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBarrierPositionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeBarrierPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBarrierPositionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterPumpConfigurationAndControl

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

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

- (void)readAttributeMaxPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxCompPressureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstFlowWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxConstTempWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePumpStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePumpStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlPumpStatusAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEffectiveOperationModeWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEffectiveOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEffectiveControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEffectiveControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLifetimeRunningHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLifetimeRunningHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLifetimeEnergyConsumedWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLifetimeEnergyConsumedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeControlModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlClusterPumpControlModeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;
                chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PumpConfigurationAndControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::PumpConfigurationAndControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPumpConfigurationAndControl (Deprecated)

- (void)readAttributeMaxPressureWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPressureWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxPressureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxPressureWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeMaxPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxPressureWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeMaxSpeedWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxSpeedWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxSpeedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxSpeedWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeMaxSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxSpeedWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeMaxFlowWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFlowWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxFlowWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxFlowWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeMaxFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxFlowWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeMinConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstPressureWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinConstPressureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinConstPressureWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstPressureWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxConstPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstPressureWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxConstPressureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxConstPressureWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxConstPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstPressureWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMinCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCompPressureWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinCompPressureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinCompPressureWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeMinCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCompPressureWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeMaxCompPressureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCompPressureWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxCompPressureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxCompPressureWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeMaxCompPressureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCompPressureWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeMinConstSpeedWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstSpeedWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinConstSpeedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinConstSpeedWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMinConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstSpeedWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMaxConstSpeedWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstSpeedWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxConstSpeedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxConstSpeedWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMaxConstSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstSpeedWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinConstFlowWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstFlowWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinConstFlowWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinConstFlowWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMinConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstFlowWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeMaxConstFlowWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstFlowWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxConstFlowWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxConstFlowWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMaxConstFlowWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstFlowWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeMinConstTempWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstTempWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinConstTempWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinConstTempWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMinConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinConstTempWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeMaxConstTempWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstTempWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxConstTempWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxConstTempWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeMaxConstTempWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxConstTempWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributePumpStatusWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePumpStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributePumpStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePumpStatusWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributePumpStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePumpStatusWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeEffectiveOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveOperationModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeEffectiveOperationModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEffectiveOperationModeWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeEffectiveOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveOperationModeWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeEffectiveControlModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveControlModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeEffectiveControlModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEffectiveControlModeWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeEffectiveControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEffectiveControlModeWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeCapacityWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapacityWithCompletion:completionHandler];
}
- (void)subscribeAttributeCapacityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCapacityWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCapacityWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeSpeedWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedWithCompletion:completionHandler];
}
- (void)subscribeAttributeSpeedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSpeedWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeLifetimeRunningHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeRunningHoursWithCompletion:completionHandler];
}
- (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLifetimeRunningHoursWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLifetimeRunningHoursWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLifetimeRunningHoursWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLifetimeRunningHoursWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeLifetimeRunningHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeRunningHoursWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeLifetimeEnergyConsumedWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeEnergyConsumedWithCompletion:completionHandler];
}
- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)value
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLifetimeEnergyConsumedWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLifetimeEnergyConsumedWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLifetimeEnergyConsumedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLifetimeEnergyConsumedWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeLifetimeEnergyConsumedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLifetimeEnergyConsumedWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeOperationModeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationModeWithCompletion:completionHandler];
}
- (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOperationModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOperationModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOperationModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOperationModeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOperationModeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeControlModeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlModeWithCompletion:completionHandler];
}
- (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeControlModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeControlModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeControlModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeControlModeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeControlModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeControlModeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterThermostat

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

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

- (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerParams *)params
                          completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatClusterGetWeeklyScheduleResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            Thermostat::Commands::ClearWeeklySchedule::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeLocalTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocalTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOutdoorTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOutdoorTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMinHeatSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAbsMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMaxHeatSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMinCoolSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAbsMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAbsMaxCoolSetpointLimitWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePICoolingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePICoolingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePIHeatingDemandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePIHeatingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHVACSystemTypeConfigurationWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHVACSystemTypeConfigurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLocalTemperatureCalibrationWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLocalTemperatureCalibrationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedCoolingSetpointWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedHeatingSetpointWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedCoolingSetpointWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnoccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedHeatingSetpointWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnoccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxHeatSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxCoolSetpointLimitWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinSetpointDeadBandWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinSetpointDeadBandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemoteSensingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRemoteSensingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeControlSequenceOfOperationWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeControlSequenceOfOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatClusterThermostatControlSequenceAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSystemModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSystemModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatRunningModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeThermostatRunningModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartOfWeekWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartOfWeekWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfWeeklyTransitionsWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfWeeklyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfDailyTransitionsWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfDailyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTemperatureSetpointHoldWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTemperatureSetpointHoldWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTemperatureSetpointHoldDurationWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTemperatureSetpointHoldDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatProgrammingOperationModeWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeThermostatProgrammingOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeThermostatRunningStateWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeThermostatRunningStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeSourceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSetpointChangeSourceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeAmountWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSetpointChangeAmountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSetpointChangeSourceTimestampWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSetpointChangeSourceTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnoccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnoccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnoccupiedSetbackMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnoccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEmergencyHeatDeltaWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEmergencyHeatDeltaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCapacityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACRefrigerantTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACRefrigerantTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCompressorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACCompressorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACErrorCodeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACErrorCodeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACLouverPositionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACLouverPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCoilTemperatureWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACCoilTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeACCapacityformatWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeACCapacityformatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ThermostatAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ThermostatAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::AttributeList::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ThermostatAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ThermostatCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThermostat (Deprecated)

- (void)setpointRaiseLowerWithParams:(MTRThermostatClusterSetpointRaiseLowerParams *)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setpointRaiseLowerWithParams:params completion:completionHandler];
}
- (void)setWeeklyScheduleWithParams:(MTRThermostatClusterSetWeeklyScheduleParams *)params
                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self setWeeklyScheduleWithParams:params completion:completionHandler];
}
- (void)getWeeklyScheduleWithParams:(MTRThermostatClusterGetWeeklyScheduleParams *)params
                  completionHandler:(void (^)(MTRThermostatClusterGetWeeklyScheduleResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    [self getWeeklyScheduleWithParams:params completion:completionHandler];
}
- (void)clearWeeklyScheduleWithParams:(MTRThermostatClusterClearWeeklyScheduleParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearWeeklyScheduleWithParams:params completion:completionHandler];
}
- (void)clearWeeklyScheduleWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self clearWeeklyScheduleWithParams:nil completion:completionHandler];
}

- (void)readAttributeLocalTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeLocalTemperatureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocalTemperatureWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeLocalTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeOutdoorTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeOutdoorTemperatureWithCompletion:completionHandler];
}
- (void)subscribeAttributeOutdoorTemperatureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOutdoorTemperatureWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeOutdoorTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutdoorTemperatureWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeOccupancyWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupancyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupancyWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeAbsMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinHeatSetpointLimitWithCompletion:completionHandler];
}
- (void)subscribeAttributeAbsMinHeatSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAbsMinHeatSetpointLimitWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeAbsMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinHeatSetpointLimitWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeAbsMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxHeatSetpointLimitWithCompletion:completionHandler];
}
- (void)subscribeAttributeAbsMaxHeatSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAbsMaxHeatSetpointLimitWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxHeatSetpointLimitWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeAbsMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinCoolSetpointLimitWithCompletion:completionHandler];
}
- (void)subscribeAttributeAbsMinCoolSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAbsMinCoolSetpointLimitWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeAbsMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMinCoolSetpointLimitWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeAbsMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxCoolSetpointLimitWithCompletion:completionHandler];
}
- (void)subscribeAttributeAbsMaxCoolSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAbsMaxCoolSetpointLimitWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAbsMaxCoolSetpointLimitWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributePICoolingDemandWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributePICoolingDemandWithCompletion:completionHandler];
}
- (void)subscribeAttributePICoolingDemandWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePICoolingDemandWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributePICoolingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePICoolingDemandWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributePIHeatingDemandWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributePIHeatingDemandWithCompletion:completionHandler];
}
- (void)subscribeAttributePIHeatingDemandWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePIHeatingDemandWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributePIHeatingDemandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePIHeatingDemandWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeHVACSystemTypeConfigurationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeHVACSystemTypeConfigurationWithCompletion:completionHandler];
}
- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeHVACSystemTypeConfigurationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeHVACSystemTypeConfigurationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeHVACSystemTypeConfigurationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHVACSystemTypeConfigurationWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeHVACSystemTypeConfigurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeHVACSystemTypeConfigurationWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeLocalTemperatureCalibrationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureCalibrationWithCompletion:completionHandler];
}
- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalTemperatureCalibrationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLocalTemperatureCalibrationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLocalTemperatureCalibrationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLocalTemperatureCalibrationWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeLocalTemperatureCalibrationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeLocalTemperatureCalibrationWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeOccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedCoolingSetpointWithCompletion:completionHandler];
}
- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedCoolingSetpointWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedCoolingSetpointWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOccupiedCoolingSetpointWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupiedCoolingSetpointWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeOccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedCoolingSetpointWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeOccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedHeatingSetpointWithCompletion:completionHandler];
}
- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedHeatingSetpointWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedHeatingSetpointWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOccupiedHeatingSetpointWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupiedHeatingSetpointWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeOccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedHeatingSetpointWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeUnoccupiedCoolingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedCoolingSetpointWithCompletion:completionHandler];
}
- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedCoolingSetpointWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedCoolingSetpointWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUnoccupiedCoolingSetpointWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnoccupiedCoolingSetpointWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeUnoccupiedCoolingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedCoolingSetpointWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeUnoccupiedHeatingSetpointWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedHeatingSetpointWithCompletion:completionHandler];
}
- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedHeatingSetpointWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)value
                                                  params:(MTRWriteParams * _Nullable)params
                                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedHeatingSetpointWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUnoccupiedHeatingSetpointWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnoccupiedHeatingSetpointWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeUnoccupiedHeatingSetpointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedHeatingSetpointWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeMinHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeMinHeatSetpointLimitWithCompletion:completionHandler];
}
- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinHeatSetpointLimitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinHeatSetpointLimitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMinHeatSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinHeatSetpointLimitWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeMinHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinHeatSetpointLimitWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeMaxHeatSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxHeatSetpointLimitWithCompletion:completionHandler];
}
- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxHeatSetpointLimitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxHeatSetpointLimitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMaxHeatSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxHeatSetpointLimitWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeMaxHeatSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxHeatSetpointLimitWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeMinCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCoolSetpointLimitWithCompletion:completionHandler];
}
- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinCoolSetpointLimitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinCoolSetpointLimitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMinCoolSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinCoolSetpointLimitWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeMinCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinCoolSetpointLimitWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeMaxCoolSetpointLimitWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCoolSetpointLimitWithCompletion:completionHandler];
}
- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxCoolSetpointLimitWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxCoolSetpointLimitWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMaxCoolSetpointLimitWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxCoolSetpointLimitWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeMaxCoolSetpointLimitWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxCoolSetpointLimitWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeMinSetpointDeadBandWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeMinSetpointDeadBandWithCompletion:completionHandler];
}
- (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinSetpointDeadBandWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinSetpointDeadBandWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMinSetpointDeadBandWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinSetpointDeadBandWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeMinSetpointDeadBandWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinSetpointDeadBandWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRemoteSensingWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemoteSensingWithCompletion:completionHandler];
}
- (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRemoteSensingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRemoteSensingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRemoteSensingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRemoteSensingWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRemoteSensingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemoteSensingWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeControlSequenceOfOperationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeControlSequenceOfOperationWithCompletion:completionHandler];
}
- (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeControlSequenceOfOperationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)value
                                                   params:(MTRWriteParams * _Nullable)params
                                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeControlSequenceOfOperationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeControlSequenceOfOperationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeControlSequenceOfOperationWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeControlSequenceOfOperationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeControlSequenceOfOperationWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeSystemModeWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSystemModeWithCompletion:completionHandler];
}
- (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSystemModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSystemModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSystemModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSystemModeWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeSystemModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSystemModeWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeThermostatRunningModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeThermostatRunningModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeThermostatRunningModeWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeThermostatRunningModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningModeWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeStartOfWeekWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartOfWeekWithCompletion:completionHandler];
}
- (void)subscribeAttributeStartOfWeekWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartOfWeekWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeStartOfWeekWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartOfWeekWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeNumberOfWeeklyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeeklyTransitionsWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfWeeklyTransitionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfWeeklyTransitionsWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfWeeklyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfWeeklyTransitionsWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeNumberOfDailyTransitionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfDailyTransitionsWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfDailyTransitionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfDailyTransitionsWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfDailyTransitionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfDailyTransitionsWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeTemperatureSetpointHoldWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldWithCompletion:completionHandler];
}
- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureSetpointHoldWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)value
                                                params:(MTRWriteParams * _Nullable)params
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureSetpointHoldWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeTemperatureSetpointHoldWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTemperatureSetpointHoldWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeTemperatureSetpointHoldWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeTemperatureSetpointHoldDurationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldDurationWithCompletion:completionHandler];
}
- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable)value
                                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureSetpointHoldDurationWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Nullable)value
                                                        params:(MTRWriteParams * _Nullable)params
                                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureSetpointHoldDurationWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeTemperatureSetpointHoldDurationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTemperatureSetpointHoldDurationWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeTemperatureSetpointHoldDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureSetpointHoldDurationWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeThermostatProgrammingOperationModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatProgrammingOperationModeWithCompletion:completionHandler];
}
- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeThermostatProgrammingOperationModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _Nonnull)value
                                                           params:(MTRWriteParams * _Nullable)params
                                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeThermostatProgrammingOperationModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeThermostatProgrammingOperationModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeThermostatProgrammingOperationModeWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeThermostatProgrammingOperationModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatProgrammingOperationModeWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeThermostatRunningStateWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeThermostatRunningStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeThermostatRunningStateWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeThermostatRunningStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeThermostatRunningStateWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeSetpointChangeSourceWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceWithCompletion:completionHandler];
}
- (void)subscribeAttributeSetpointChangeSourceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSetpointChangeSourceWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeSetpointChangeSourceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeSetpointChangeAmountWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeAmountWithCompletion:completionHandler];
}
- (void)subscribeAttributeSetpointChangeAmountWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSetpointChangeAmountWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeSetpointChangeAmountWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeAmountWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeSetpointChangeSourceTimestampWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceTimestampWithCompletion:completionHandler];
}
- (void)subscribeAttributeSetpointChangeSourceTimestampWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSetpointChangeSourceTimestampWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeSetpointChangeSourceTimestampWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeSetpointChangeSourceTimestampWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeOccupiedSetbackWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackWithCompletion:completionHandler];
}
- (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedSetbackWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOccupiedSetbackWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOccupiedSetbackWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupiedSetbackWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeOccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeOccupiedSetbackMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupiedSetbackMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupiedSetbackMinWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeOccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMinWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeOccupiedSetbackMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupiedSetbackMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupiedSetbackMaxWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeOccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupiedSetbackMaxWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeUnoccupiedSetbackWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackWithCompletion:completionHandler];
}
- (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedSetbackWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnoccupiedSetbackWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUnoccupiedSetbackWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnoccupiedSetbackWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeUnoccupiedSetbackWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeUnoccupiedSetbackMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeUnoccupiedSetbackMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnoccupiedSetbackMinWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeUnoccupiedSetbackMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMinWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeUnoccupiedSetbackMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeUnoccupiedSetbackMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnoccupiedSetbackMaxWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeUnoccupiedSetbackMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnoccupiedSetbackMaxWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeEmergencyHeatDeltaWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeEmergencyHeatDeltaWithCompletion:completionHandler];
}
- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEmergencyHeatDeltaWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEmergencyHeatDeltaWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEmergencyHeatDeltaWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEmergencyHeatDeltaWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeEmergencyHeatDeltaWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEmergencyHeatDeltaWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeACTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACTypeWithCompletion:completionHandler];
}
- (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACTypeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACTypeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeACTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACTypeWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeACTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACTypeWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeACCapacityWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityWithCompletion:completionHandler];
}
- (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCapacityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCapacityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeACCapacityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACCapacityWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeACCapacityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeACRefrigerantTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeACRefrigerantTypeWithCompletion:completionHandler];
}
- (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACRefrigerantTypeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACRefrigerantTypeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeACRefrigerantTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACRefrigerantTypeWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeACRefrigerantTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACRefrigerantTypeWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeACCompressorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeACCompressorTypeWithCompletion:completionHandler];
}
- (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCompressorTypeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCompressorTypeWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeACCompressorTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACCompressorTypeWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeACCompressorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCompressorTypeWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeACErrorCodeWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACErrorCodeWithCompletion:completionHandler];
}
- (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACErrorCodeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACErrorCodeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeACErrorCodeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACErrorCodeWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeACErrorCodeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACErrorCodeWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeACLouverPositionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeACLouverPositionWithCompletion:completionHandler];
}
- (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACLouverPositionWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACLouverPositionWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeACLouverPositionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACLouverPositionWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeACLouverPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACLouverPositionWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeACCoilTemperatureWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeACCoilTemperatureWithCompletion:completionHandler];
}
- (void)subscribeAttributeACCoilTemperatureWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACCoilTemperatureWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeACCoilTemperatureWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCoilTemperatureWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeACCapacityformatWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityformatWithCompletion:completionHandler];
}
- (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCapacityformatWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeACCapacityformatWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeACCapacityformatWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeACCapacityformatWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeACCapacityformatWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeACCapacityformatWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterFanControl

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

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

- (void)readAttributeFanModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlClusterFanModeTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlClusterFanModeTypeAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFanModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FanControlClusterFanModeTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFanModeSequenceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFanModeSequenceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FanControlClusterFanModeSequenceTypeAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePercentSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePercentSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePercentCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePercentCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSpeedMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSpeedSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSpeedCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSpeedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRockSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRockSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRockSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRockSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWindSupportWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWindSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWindSettingWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWindSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FanControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FanControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FanControlAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFanControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FanControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::FanControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFanControl (Deprecated)

- (void)readAttributeFanModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeWithCompletion:completionHandler];
}
- (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFanModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFanModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeFanModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFanModeWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeFanModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeFanModeSequenceWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeSequenceWithCompletion:completionHandler];
}
- (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFanModeSequenceWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFanModeSequenceWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeFanModeSequenceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFanModeSequenceWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeFanModeSequenceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFanModeSequenceWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributePercentSettingWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributePercentSettingWithCompletion:completionHandler];
}
- (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePercentSettingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePercentSettingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePercentSettingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePercentSettingWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributePercentSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentSettingWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributePercentCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributePercentCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributePercentCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePercentCurrentWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributePercentCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePercentCurrentWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeSpeedMaxWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeSpeedMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSpeedMaxWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeSpeedMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedMaxWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeSpeedSettingWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedSettingWithCompletion:completionHandler];
}
- (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSpeedSettingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSpeedSettingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSpeedSettingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSpeedSettingWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSpeedSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedSettingWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSpeedCurrentWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeSpeedCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSpeedCurrentWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSpeedCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSpeedCurrentWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeRockSupportWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSupportWithCompletion:completionHandler];
}
- (void)subscribeAttributeRockSupportWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRockSupportWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeRockSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSupportWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeRockSettingWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSettingWithCompletion:completionHandler];
}
- (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRockSettingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRockSettingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRockSettingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRockSettingWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeRockSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRockSettingWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeWindSupportWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSupportWithCompletion:completionHandler];
}
- (void)subscribeAttributeWindSupportWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWindSupportWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeWindSupportWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSupportWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeWindSettingWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSettingWithCompletion:completionHandler];
}
- (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWindSettingWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWindSettingWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeWindSettingWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWindSettingWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeWindSettingWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWindSettingWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterThermostatUserInterfaceConfiguration

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

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

- (void)readAttributeTemperatureDisplayModeWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTemperatureDisplayModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeKeypadLockoutWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeKeypadLockoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScheduleProgrammingVisibilityWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeScheduleProgrammingVisibilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;
                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(
                    bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;
                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(
                    bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;
                chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(
                    bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterThermostatUserInterfaceConfiguration (Deprecated)

- (void)readAttributeTemperatureDisplayModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureDisplayModeWithCompletion:completionHandler];
}
- (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureDisplayModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value
                                               params:(MTRWriteParams * _Nullable)params
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTemperatureDisplayModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeTemperatureDisplayModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTemperatureDisplayModeWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeTemperatureDisplayModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTemperatureDisplayModeWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeKeypadLockoutWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeKeypadLockoutWithCompletion:completionHandler];
}
- (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeKeypadLockoutWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeKeypadLockoutWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeKeypadLockoutWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeKeypadLockoutWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeKeypadLockoutWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeKeypadLockoutWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeScheduleProgrammingVisibilityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeScheduleProgrammingVisibilityWithCompletion:completionHandler];
}
- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeScheduleProgrammingVisibilityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnull)value
                                                      params:(MTRWriteParams * _Nullable)params
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeScheduleProgrammingVisibilityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeScheduleProgrammingVisibilityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeScheduleProgrammingVisibilityWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeScheduleProgrammingVisibilityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeScheduleProgrammingVisibilityWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterColorControl

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

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

- (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
                              completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
                                      completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
                            completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentSaturationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentSaturationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRemainingTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDriftCompensationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDriftCompensationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCompensationTextWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCompensationTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTemperatureMiredsWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTemperatureMireds::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOptionsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNumberOfPrimariesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNumberOfPrimariesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary1XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary1YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary1IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary1IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary2XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary2YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary2IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary2IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary3XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary3YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary3IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary3IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary4XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary4YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary4IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary4IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary5XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary5YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary5IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary5IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6XWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary6XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6YWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary6YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePrimary6IntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePrimary6IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWhitePointXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWhitePointXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWhitePointYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWhitePointYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointRXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointRYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointRIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointRIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointGXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointGYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointGIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointGIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBXWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointBXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBYWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointBYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorPointBIntensityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorPointBIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnhancedCurrentHueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnhancedCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnhancedColorModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnhancedColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopActiveWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorLoopActiveWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopDirectionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorLoopDirectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorLoopTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopStartEnhancedHueWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorLoopStartEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorLoopStoredEnhancedHueWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorLoopStoredEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorCapabilitiesWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTempPhysicalMinMiredsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMinMireds::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorTempPhysicalMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeColorTempPhysicalMaxMiredsWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMaxMireds::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStartUpColorTemperatureMiredsWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartUpColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ColorControlGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ColorControlAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::AttributeList::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRColorControlAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ColorControlAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ColorControlCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterColorControl (Deprecated)

- (void)moveToHueWithParams:(MTRColorControlClusterMoveToHueParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToHueWithParams:params completion:completionHandler];
}
- (void)moveHueWithParams:(MTRColorControlClusterMoveHueParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveHueWithParams:params completion:completionHandler];
}
- (void)stepHueWithParams:(MTRColorControlClusterStepHueParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepHueWithParams:params completion:completionHandler];
}
- (void)moveToSaturationWithParams:(MTRColorControlClusterMoveToSaturationParams *)params
                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToSaturationWithParams:params completion:completionHandler];
}
- (void)moveSaturationWithParams:(MTRColorControlClusterMoveSaturationParams *)params
               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveSaturationWithParams:params completion:completionHandler];
}
- (void)stepSaturationWithParams:(MTRColorControlClusterStepSaturationParams *)params
               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepSaturationWithParams:params completion:completionHandler];
}
- (void)moveToHueAndSaturationWithParams:(MTRColorControlClusterMoveToHueAndSaturationParams *)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToHueAndSaturationWithParams:params completion:completionHandler];
}
- (void)moveToColorWithParams:(MTRColorControlClusterMoveToColorParams *)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToColorWithParams:params completion:completionHandler];
}
- (void)moveColorWithParams:(MTRColorControlClusterMoveColorParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveColorWithParams:params completion:completionHandler];
}
- (void)stepColorWithParams:(MTRColorControlClusterStepColorParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepColorWithParams:params completion:completionHandler];
}
- (void)moveToColorTemperatureWithParams:(MTRColorControlClusterMoveToColorTemperatureParams *)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveToColorTemperatureWithParams:params completion:completionHandler];
}
- (void)enhancedMoveToHueWithParams:(MTRColorControlClusterEnhancedMoveToHueParams *)params
                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enhancedMoveToHueWithParams:params completion:completionHandler];
}
- (void)enhancedMoveHueWithParams:(MTRColorControlClusterEnhancedMoveHueParams *)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enhancedMoveHueWithParams:params completion:completionHandler];
}
- (void)enhancedStepHueWithParams:(MTRColorControlClusterEnhancedStepHueParams *)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enhancedStepHueWithParams:params completion:completionHandler];
}
- (void)enhancedMoveToHueAndSaturationWithParams:(MTRColorControlClusterEnhancedMoveToHueAndSaturationParams *)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self enhancedMoveToHueAndSaturationWithParams:params completion:completionHandler];
}
- (void)colorLoopSetWithParams:(MTRColorControlClusterColorLoopSetParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self colorLoopSetWithParams:params completion:completionHandler];
}
- (void)stopMoveStepWithParams:(MTRColorControlClusterStopMoveStepParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stopMoveStepWithParams:params completion:completionHandler];
}
- (void)moveColorTemperatureWithParams:(MTRColorControlClusterMoveColorTemperatureParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self moveColorTemperatureWithParams:params completion:completionHandler];
}
- (void)stepColorTemperatureWithParams:(MTRColorControlClusterStepColorTemperatureParams *)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self stepColorTemperatureWithParams:params completion:completionHandler];
}

- (void)readAttributeCurrentHueWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHueWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentHueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentHueWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentHueWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeCurrentSaturationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSaturationWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentSaturationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentSaturationWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeCurrentSaturationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentSaturationWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeRemainingTimeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithCompletion:completionHandler];
}
- (void)subscribeAttributeRemainingTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRemainingTimeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRemainingTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRemainingTimeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeCurrentXWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentXWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentXWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentXWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeCurrentXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentXWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeCurrentYWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentYWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentYWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentYWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeCurrentYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentYWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeDriftCompensationWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeDriftCompensationWithCompletion:completionHandler];
}
- (void)subscribeAttributeDriftCompensationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDriftCompensationWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeDriftCompensationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDriftCompensationWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeCompensationTextWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeCompensationTextWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeCompensationTextWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCompensationTextWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeCompensationTextWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCompensationTextWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTemperatureMiredsWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorTemperatureMiredsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorTemperatureMiredsWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTemperatureMiredsWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeColorModeWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorModeWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorModeWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeOptionsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithCompletion:completionHandler];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOptionsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOptionsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOptionsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOptionsWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeOptionsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOptionsWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeNumberOfPrimariesWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPrimariesWithCompletion:completionHandler];
}
- (void)subscribeAttributeNumberOfPrimariesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNumberOfPrimariesWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeNumberOfPrimariesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNumberOfPrimariesWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary1XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary1XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary1XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary1XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary1YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary1YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary1YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary1YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary1IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary1IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary1IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary1IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary1IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary2XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary2XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary2XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary2XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary2YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary2YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary2YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary2YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary2IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary2IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary2IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary2IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary2IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary3XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary3XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary3XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary3XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary3YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary3YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary3YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary3YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary3IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary3IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary3IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary3IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary3IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary4XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary4XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary4XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary4XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary4YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary4YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary4YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary4YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary4IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary4IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary4IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary4IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary4IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary5XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary5XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary5XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary5XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary5YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary5YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary5YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary5YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary5IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary5IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary5IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary5IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary5IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributePrimary6XWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6XWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary6XWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary6XWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary6XWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6XWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary6YWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6YWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary6YWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary6YWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributePrimary6YWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6YWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributePrimary6IntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6IntensityWithCompletion:completionHandler];
}
- (void)subscribeAttributePrimary6IntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePrimary6IntensityWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePrimary6IntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePrimary6IntensityWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeWhitePointXWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointXWithCompletion:completionHandler];
}
- (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWhitePointXWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWhitePointXWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeWhitePointXWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWhitePointXWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeWhitePointXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointXWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeWhitePointYWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointYWithCompletion:completionHandler];
}
- (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWhitePointYWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWhitePointYWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeWhitePointYWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWhitePointYWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeWhitePointYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWhitePointYWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeColorPointRXWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRXWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRXWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRXWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointRXWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointRXWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointRXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRXWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointRYWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRYWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRYWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRYWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointRYWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointRYWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointRYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRYWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointRIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRIntensityWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRIntensityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointRIntensityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointRIntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointRIntensityWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeColorPointRIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointRIntensityWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeColorPointGXWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGXWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGXWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGXWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointGXWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointGXWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointGXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGXWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointGYWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGYWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGYWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGYWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointGYWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointGYWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointGYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGYWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointGIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGIntensityWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGIntensityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointGIntensityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointGIntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointGIntensityWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeColorPointGIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointGIntensityWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeColorPointBXWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBXWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBXWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBXWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointBXWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointBXWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointBXWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBXWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointBYWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBYWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBYWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value
                                     params:(MTRWriteParams * _Nullable)params
                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBYWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointBYWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointBYWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeColorPointBYWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBYWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeColorPointBIntensityWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBIntensityWithCompletion:completionHandler];
}
- (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBIntensityWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeColorPointBIntensityWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeColorPointBIntensityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorPointBIntensityWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeColorPointBIntensityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorPointBIntensityWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeEnhancedCurrentHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedCurrentHueWithCompletion:completionHandler];
}
- (void)subscribeAttributeEnhancedCurrentHueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnhancedCurrentHueWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeEnhancedCurrentHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedCurrentHueWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeEnhancedColorModeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedColorModeWithCompletion:completionHandler];
}
- (void)subscribeAttributeEnhancedColorModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnhancedColorModeWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeEnhancedColorModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnhancedColorModeWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeColorLoopActiveWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopActiveWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorLoopActiveWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorLoopActiveWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeColorLoopActiveWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopActiveWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeColorLoopDirectionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopDirectionWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorLoopDirectionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorLoopDirectionWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeColorLoopDirectionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopDirectionWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeColorLoopTimeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopTimeWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorLoopTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorLoopTimeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeColorLoopTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopTimeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeColorLoopStartEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStartEnhancedHueWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorLoopStartEnhancedHueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorLoopStartEnhancedHueWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeColorLoopStartEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStartEnhancedHueWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeColorLoopStoredEnhancedHueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStoredEnhancedHueWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorLoopStoredEnhancedHueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorLoopStoredEnhancedHueWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeColorLoopStoredEnhancedHueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeColorLoopStoredEnhancedHueWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeColorCapabilitiesWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeColorCapabilitiesWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorCapabilitiesWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorCapabilitiesWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeColorCapabilitiesWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeColorCapabilitiesWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeColorTempPhysicalMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMinMiredsWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorTempPhysicalMinMiredsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorTempPhysicalMinMiredsWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeColorTempPhysicalMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMinMiredsWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeColorTempPhysicalMaxMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMaxMiredsWithCompletion:completionHandler];
}
- (void)subscribeAttributeColorTempPhysicalMaxMiredsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeColorTempPhysicalMaxMiredsWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeColorTempPhysicalMaxMiredsWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeCoupleColorTempToLevelMinMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeCoupleColorTempToLevelMinMiredsWithCompletion:completionHandler];
}
- (void)subscribeAttributeCoupleColorTempToLevelMinMiredsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCoupleColorTempToLevelMinMiredsWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeCoupleColorTempToLevelMinMiredsWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeStartUpColorTemperatureMiredsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpColorTemperatureMiredsWithCompletion:completionHandler];
}
- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable)value
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpColorTemperatureMiredsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStartUpColorTemperatureMiredsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeStartUpColorTemperatureMiredsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartUpColorTemperatureMiredsWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeStartUpColorTemperatureMiredsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeStartUpColorTemperatureMiredsWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterBallastConfiguration

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

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

- (void)readAttributePhysicalMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMinLevel::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::PhysicalMaxLevel::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBallastStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::BallastStatus::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBallastStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxLevelWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeIntrinsicBalanceFactorWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBalanceFactor::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeIntrinsicBalanceFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBallastFactorAdjustmentWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBallastFactorAdjustmentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampQuantityWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampQuantity::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampTypeWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampManufacturerWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampManufacturerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampRatedHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampRatedHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampBurnHoursWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampBurnHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampAlarmModeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampAlarmModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLampBurnHoursTripPointWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLampBurnHoursTripPointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BallastConfigurationGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BallastConfigurationAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::AttributeList::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(BallastConfigurationAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::FeatureMap::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = BallastConfiguration::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::BallastConfigurationCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterBallastConfiguration (Deprecated)

- (void)readAttributePhysicalMinLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMinLevelWithCompletion:completionHandler];
}
- (void)
    subscribeAttributePhysicalMinLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalMinLevelWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributePhysicalMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMinLevelWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributePhysicalMaxLevelWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMaxLevelWithCompletion:completionHandler];
}
- (void)
    subscribeAttributePhysicalMaxLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalMaxLevelWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributePhysicalMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalMaxLevelWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeBallastStatusWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeBallastStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBallastStatusWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeBallastStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastStatusWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinLevelWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithCompletion:completionHandler];
}
- (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinLevelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMinLevelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMinLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinLevelWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeMinLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinLevelWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeMaxLevelWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithCompletion:completionHandler];
}
- (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxLevelWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeMaxLevelWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeMaxLevelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxLevelWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeMaxLevelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxLevelWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeIntrinsicBalanceFactorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeIntrinsicBalanceFactorWithCompletion:completionHandler];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIntrinsicBalanceFactorWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeIntrinsicBalanceFactorWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeIntrinsicBalanceFactorWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeIntrinsicBalanceFactorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeIntrinsicBalanceFactorWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeIntrinsicBalanceFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeIntrinsicBalanceFactorWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeBallastFactorAdjustmentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastFactorAdjustmentWithCompletion:completionHandler];
}
- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)value
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBallastFactorAdjustmentWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)value
                                                params:(MTRWriteParams * _Nullable)params
                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBallastFactorAdjustmentWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBallastFactorAdjustmentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBallastFactorAdjustmentWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeBallastFactorAdjustmentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBallastFactorAdjustmentWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeLampQuantityWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampQuantityWithCompletion:completionHandler];
}
- (void)subscribeAttributeLampQuantityWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampQuantityWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeLampQuantityWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampQuantityWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeLampTypeWithCompletionHandler:(void (^)(
                                                       NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampTypeWithCompletion:completionHandler];
}
- (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampTypeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampTypeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLampTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampTypeWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeLampTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampTypeWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeLampManufacturerWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeLampManufacturerWithCompletion:completionHandler];
}
- (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampManufacturerWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampManufacturerWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeLampManufacturerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampManufacturerWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeLampManufacturerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampManufacturerWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeLampRatedHoursWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeLampRatedHoursWithCompletion:completionHandler];
}
- (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampRatedHoursWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampRatedHoursWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLampRatedHoursWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampRatedHoursWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeLampRatedHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampRatedHoursWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeLampBurnHoursWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursWithCompletion:completionHandler];
}
- (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampBurnHoursWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampBurnHoursWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLampBurnHoursWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampBurnHoursWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeLampBurnHoursWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeLampAlarmModeWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampAlarmModeWithCompletion:completionHandler];
}
- (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampAlarmModeWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampAlarmModeWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLampAlarmModeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampAlarmModeWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeLampAlarmModeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampAlarmModeWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeLampBurnHoursTripPointWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursTripPointWithCompletion:completionHandler];
}
- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)value
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampBurnHoursTripPointWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)value
                                               params:(MTRWriteParams * _Nullable)params
                                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLampBurnHoursTripPointWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLampBurnHoursTripPointWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLampBurnHoursTripPointWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeLampBurnHoursTripPointWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLampBurnHoursTripPointWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterIlluminanceMeasurement

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

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLightSensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLightSensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(IlluminanceMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(IlluminanceMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(IlluminanceMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::IlluminanceMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterIlluminanceMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredValueWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeToleranceWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeLightSensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeLightSensorTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeLightSensorTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLightSensorTypeWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeLightSensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLightSensorTypeWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterTemperatureMeasurement

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

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TemperatureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TemperatureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TemperatureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::TemperatureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTemperatureMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredValueWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeToleranceWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterPressureMeasurement

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

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxScaledValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaledToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeScaledToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeScaleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeScaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PressureMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PressureMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(PressureMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::PressureMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterPressureMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredValueWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeToleranceWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeScaledValueWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeScaledValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeScaledValueWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledValueWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeMinScaledValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeMinScaledValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMinScaledValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinScaledValueWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeMinScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinScaledValueWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeMaxScaledValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxScaledValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMaxScaledValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxScaledValueWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeMaxScaledValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxScaledValueWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeScaledToleranceWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeScaledToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeScaledToleranceWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeScaledToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaledToleranceWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeScaleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaleWithCompletion:completionHandler];
}
- (void)subscribeAttributeScaleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeScaleWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeScaleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeScaleWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterFlowMeasurement

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

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FlowMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FlowMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(FlowMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::FlowMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterFlowMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredValueWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeToleranceWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterRelativeHumidityMeasurement

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

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

- (void)readAttributeMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMinMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMaxMeasuredValueWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeToleranceWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge
        = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
            ^(ExchangeManager & exchangeManager, const SessionHandle & session,
                RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
                MTRCallbackBridgeBase * bridge) {
                using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;
                chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
                return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
            });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::
                    OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(RelativeHumidityMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::RelativeHumidityMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterRelativeHumidityMeasurement (Deprecated)

- (void)readAttributeMeasuredValueWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredValueWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredValueWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeMinMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMinMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMinMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMinMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMinMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeMaxMeasuredValueWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeMaxMeasuredValueWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMaxMeasuredValueWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeMaxMeasuredValueWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMaxMeasuredValueWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeToleranceWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithCompletion:completionHandler];
}
- (void)subscribeAttributeToleranceWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeToleranceWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeToleranceWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeToleranceWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterOccupancySensing

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

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

- (void)readAttributeOccupancyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancySensorTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupancySensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOccupancySensorTypeBitmapWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOccupancySensorTypeBitmapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePirOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirOccupiedToUnoccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePirUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePirUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PirUnoccupiedToOccupiedThreshold::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                      endpoint:(NSNumber *)endpoint
                                                                         queue:(dispatch_queue_t)queue
                                                                    completion:(void (^)(NSNumber * _Nullable value,
                                                                                   NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                           endpoint:(NSNumber *)endpoint
                                                                              queue:(dispatch_queue_t)queue
                                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OccupancySensingGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OccupancySensingAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::AttributeList::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(OccupancySensingAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::OccupancySensingCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterOccupancySensing (Deprecated)

- (void)readAttributeOccupancyWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupancyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupancyWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeOccupancyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancyWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeOccupancySensorTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupancySensorTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupancySensorTypeWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeOccupancySensorTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeOccupancySensorTypeBitmapWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeBitmapWithCompletion:completionHandler];
}
- (void)subscribeAttributeOccupancySensorTypeBitmapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOccupancySensorTypeBitmapWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeOccupancySensorTypeBitmapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeOccupancySensorTypeBitmapWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributePirOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributePirOccupiedToUnoccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirOccupiedToUnoccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePirOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirOccupiedToUnoccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePirOccupiedToUnoccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePirOccupiedToUnoccupiedDelayWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributePirOccupiedToUnoccupiedDelayWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributePirUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributePirUnoccupiedToOccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirUnoccupiedToOccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePirUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirUnoccupiedToOccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePirUnoccupiedToOccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePirUnoccupiedToOccupiedDelayWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributePirUnoccupiedToOccupiedDelayWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributePirUnoccupiedToOccupiedThresholdWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributePirUnoccupiedToOccupiedThresholdWithCompletion:completionHandler];
}
- (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirUnoccupiedToOccupiedThresholdWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePirUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                         params:(MTRWriteParams * _Nullable)params
                                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePirUnoccupiedToOccupiedThresholdWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePirUnoccupiedToOccupiedThresholdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                              maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                   params:(MTRSubscribeParams * _Nullable)params
                                                  subscriptionEstablished:
                                                      (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                            reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePirUnoccupiedToOccupiedThresholdWithParams:subscribeParams
                                               subscriptionEstablished:subscriptionEstablishedHandler
                                                         reportHandler:reportHandler];
}
+ (void)readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                      completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributePirUnoccupiedToOccupiedThresholdWithAttributeCache:attributeCacheContainer
                                                                 endpoint:endpoint
                                                                    queue:queue
                                                               completion:completionHandler];
}

- (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicOccupiedToUnoccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                            params:(MTRWriteParams * _Nullable)params
                                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUltrasonicOccupiedToUnoccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                      params:(MTRSubscribeParams * _Nullable)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUltrasonicOccupiedToUnoccupiedDelayWithParams:subscribeParams
                                                  subscriptionEstablished:subscriptionEstablishedHandler
                                                            reportHandler:reportHandler];
}
+ (void)readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                         completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicOccupiedToUnoccupiedDelayWithAttributeCache:attributeCacheContainer
                                                                    endpoint:endpoint
                                                                       queue:queue
                                                                  completion:completionHandler];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                            params:(MTRWriteParams * _Nullable)params
                                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                      params:(MTRSubscribeParams * _Nullable)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUltrasonicUnoccupiedToOccupiedDelayWithParams:subscribeParams
                                                  subscriptionEstablished:subscriptionEstablishedHandler
                                                            reportHandler:reportHandler];
}
+ (void)readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                         completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedDelayWithAttributeCache:attributeCacheContainer
                                                                    endpoint:endpoint
                                                                       queue:queue
                                                                  completion:completionHandler];
}

- (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithCompletion:completionHandler];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                                params:(MTRWriteParams * _Nullable)params
                                                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                          params:(MTRSubscribeParams * _Nullable)params
                                                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                     subscriptionEstablishedHandler
                                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithParams:subscribeParams
                                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                                reportHandler:reportHandler];
}
+ (void)readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                      endpoint:(NSNumber *)endpoint
                                                                         queue:(dispatch_queue_t)queue
                                                             completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeUltrasonicUnoccupiedToOccupiedThresholdWithAttributeCache:attributeCacheContainer
                                                                        endpoint:endpoint
                                                                           queue:queue
                                                                      completion:completionHandler];
}

- (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactOccupiedToUnoccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                                 params:(MTRWriteParams * _Nullable)params
                                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePhysicalContactOccupiedToUnoccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalContactOccupiedToUnoccupiedDelayWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactOccupiedToUnoccupiedDelayWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedDelayWithCompletion:completionHandler];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull)value
                                                                 params:(MTRWriteParams * _Nullable)params
                                                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedDelayWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalContactUnoccupiedToOccupiedDelayWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedDelayWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletionHandler:
    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithCompletion:completionHandler];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Nonnull)value
                                                                     params:(MTRWriteParams * _Nullable)params
                                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                               params:(MTRSubscribeParams * _Nullable)params
                                                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                          subscriptionEstablishedHandler
                                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithParams:subscribeParams
                                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                                     reportHandler:reportHandler];
}
+ (void)readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                           endpoint:(NSNumber *)endpoint
                                                                              queue:(dispatch_queue_t)queue
                                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributePhysicalContactUnoccupiedToOccupiedThresholdWithAttributeCache:attributeCacheContainer
                                                                             endpoint:endpoint
                                                                                queue:queue
                                                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterWakeOnLan

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

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

- (void)readAttributeMACAddressWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMACAddressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLanGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WakeOnLanGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLanAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(WakeOnLanAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WakeOnLanAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, WakeOnLanAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::AttributeList::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRWakeOnLanAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRWakeOnLanAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(WakeOnLanAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::WakeOnLanCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterWakeOnLan (Deprecated)

- (void)readAttributeMACAddressWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMACAddressWithCompletion:completionHandler];
}
- (void)subscribeAttributeMACAddressWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMACAddressWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeMACAddressWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMACAddressWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterChannel

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRChannelClusterChangeChannelResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ChannelClusterChangeChannelResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
                             completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeChannelListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelChannelListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelChannelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelChannelListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelChannelListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelChannelListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::ChannelList::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelChannelListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeChannelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelChannelListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ChannelChannelListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineupWithCompletion:(void (^)(
                                              MTRChannelClusterLineupInfo * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelLineupStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelLineupStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelLineupStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelLineupStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelLineupStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelLineupStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLineupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                  NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelLineupStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ChannelLineupStructAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentChannelWithCompletion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelCurrentChannelStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelCurrentChannelStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ChannelCurrentChannelStructAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ChannelGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ChannelAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, ChannelAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRChannelAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::AttributeList::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRChannelAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRChannelAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(ChannelAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ChannelCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterChannel (Deprecated)

- (void)changeChannelWithParams:(MTRChannelClusterChangeChannelParams *)params
              completionHandler:(void (^)(MTRChannelClusterChangeChannelResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    [self changeChannelWithParams:params completion:completionHandler];
}
- (void)changeChannelByNumberWithParams:(MTRChannelClusterChangeChannelByNumberParams *)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self changeChannelByNumberWithParams:params completion:completionHandler];
}
- (void)skipChannelWithParams:(MTRChannelClusterSkipChannelParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self skipChannelWithParams:params completion:completionHandler];
}

- (void)readAttributeChannelListWithCompletionHandler:(void (^)(
                                                          NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelListWithCompletion:completionHandler];
}
- (void)subscribeAttributeChannelListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeChannelListWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeChannelListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeChannelListWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeLineupWithCompletionHandler:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeLineupWithCompletion:completionHandler];
}
- (void)subscribeAttributeLineupWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                    NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLineupWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeLineupWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(MTRChannelClusterLineupInfo * _Nullable value,
                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeLineupWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeCurrentChannelWithCompletionHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentChannelWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentChannelWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                            NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentChannelWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeCurrentChannelWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:(void (^)(MTRChannelClusterChannelInfo * _Nullable value,
                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentChannelWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterTargetNavigator

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorClusterNavigateTargetResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeTargetListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::TargetList::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTargetListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TargetNavigatorTargetListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentTargetWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentTargetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TargetNavigatorGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TargetNavigatorAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::AttributeList::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TargetNavigatorAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::TargetNavigatorCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTargetNavigator (Deprecated)

- (void)navigateTargetWithParams:(MTRTargetNavigatorClusterNavigateTargetParams *)params
               completionHandler:(void (^)(MTRTargetNavigatorClusterNavigateTargetResponseParams * _Nullable data,
                                     NSError * _Nullable error))completionHandler
{
    [self navigateTargetWithParams:params completion:completionHandler];
}

- (void)readAttributeTargetListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetListWithCompletion:completionHandler];
}
- (void)subscribeAttributeTargetListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTargetListWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeTargetListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTargetListWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeCurrentTargetWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentTargetWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentTargetWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentTargetWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeCurrentTargetWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentTargetWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterMediaPlayback

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::Play::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::Pause::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::StopPlayback::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::StartOver::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::Previous::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::Next::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::Rewind::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaPlayback::Commands::FastForward::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeCurrentStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaPlaybackClusterPlaybackStateEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeStartTimeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStartTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDurationWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSampledPositionWithCompletion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSampledPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaPlaybackSampledPositionStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributePlaybackSpeedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFloatAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFloatAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePlaybackSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFloatAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FloatAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSeekRangeEndWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSeekRangeEndWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeSeekRangeStartWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSeekRangeStartWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaPlaybackGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaPlaybackAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::AttributeList::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaPlaybackAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::MediaPlaybackCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterMediaPlayback (Deprecated)

- (void)playWithParams:(MTRMediaPlaybackClusterPlayParams * _Nullable)params
     completionHandler:
         (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self playWithParams:params completion:completionHandler];
}
- (void)playWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                      NSError * _Nullable error))completionHandler
{
    [self playWithParams:nil completion:completionHandler];
}
- (void)pauseWithParams:(MTRMediaPlaybackClusterPauseParams * _Nullable)params
      completionHandler:
          (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self pauseWithParams:params completion:completionHandler];
}
- (void)pauseWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self pauseWithParams:nil completion:completionHandler];
}
- (void)stopPlaybackWithParams:(MTRMediaPlaybackClusterStopPlaybackParams * _Nullable)params
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self stopPlaybackWithParams:params completion:completionHandler];
}
- (void)stopPlaybackWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    [self stopPlaybackWithParams:nil completion:completionHandler];
}
- (void)startOverWithParams:(MTRMediaPlaybackClusterStartOverParams * _Nullable)params
          completionHandler:
              (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self startOverWithParams:params completion:completionHandler];
}
- (void)startOverWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    [self startOverWithParams:nil completion:completionHandler];
}
- (void)previousWithParams:(MTRMediaPlaybackClusterPreviousParams * _Nullable)params
         completionHandler:
             (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self previousWithParams:params completion:completionHandler];
}
- (void)previousWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                          NSError * _Nullable error))completionHandler
{
    [self previousWithParams:nil completion:completionHandler];
}
- (void)nextWithParams:(MTRMediaPlaybackClusterNextParams * _Nullable)params
     completionHandler:
         (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self nextWithParams:params completion:completionHandler];
}
- (void)nextWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                      NSError * _Nullable error))completionHandler
{
    [self nextWithParams:nil completion:completionHandler];
}
- (void)rewindWithParams:(MTRMediaPlaybackClusterRewindParams * _Nullable)params
       completionHandler:
           (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self rewindWithParams:params completion:completionHandler];
}
- (void)rewindWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                        NSError * _Nullable error))completionHandler
{
    [self rewindWithParams:nil completion:completionHandler];
}
- (void)fastForwardWithParams:(MTRMediaPlaybackClusterFastForwardParams * _Nullable)params
            completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    [self fastForwardWithParams:params completion:completionHandler];
}
- (void)fastForwardWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                             NSError * _Nullable error))completionHandler
{
    [self fastForwardWithParams:nil completion:completionHandler];
}
- (void)skipForwardWithParams:(MTRMediaPlaybackClusterSkipForwardParams *)params
            completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    [self skipForwardWithParams:params completion:completionHandler];
}
- (void)skipBackwardWithParams:(MTRMediaPlaybackClusterSkipBackwardParams *)params
             completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self skipBackwardWithParams:params completion:completionHandler];
}
- (void)seekWithParams:(MTRMediaPlaybackClusterSeekParams *)params
     completionHandler:
         (void (^)(MTRMediaPlaybackClusterPlaybackResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self seekWithParams:params completion:completionHandler];
}

- (void)readAttributeCurrentStateWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentStateWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentStateWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentStateWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeCurrentStateWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentStateWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeStartTimeWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartTimeWithCompletion:completionHandler];
}
- (void)subscribeAttributeStartTimeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStartTimeWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeStartTimeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStartTimeWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeDurationWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDurationWithCompletion:completionHandler];
}
- (void)subscribeAttributeDurationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDurationWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeDurationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDurationWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeSampledPositionWithCompletionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeSampledPositionWithCompletion:completionHandler];
}
- (void)subscribeAttributeSampledPositionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSampledPositionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeSampledPositionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:(void (^)(MTRMediaPlaybackClusterPlaybackPosition * _Nullable value,
                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeSampledPositionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributePlaybackSpeedWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePlaybackSpeedWithCompletion:completionHandler];
}
- (void)subscribeAttributePlaybackSpeedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePlaybackSpeedWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributePlaybackSpeedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePlaybackSpeedWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeSeekRangeEndWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeEndWithCompletion:completionHandler];
}
- (void)subscribeAttributeSeekRangeEndWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSeekRangeEndWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeSeekRangeEndWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeEndWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSeekRangeStartWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeStartWithCompletion:completionHandler];
}
- (void)subscribeAttributeSeekRangeStartWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSeekRangeStartWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeSeekRangeStartWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeSeekRangeStartWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterMediaInput

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

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

- (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaInput::Commands::ShowInputStatus::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            MediaInput::Commands::HideInputStatus::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeInputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputInputListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputInputListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputInputListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaInputInputListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::InputList::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputInputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputInputListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(MediaInputInputListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentInputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentInputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(MediaInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, MediaInputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::AttributeList::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRMediaInputAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(MediaInputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::MediaInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterMediaInput (Deprecated)

- (void)selectInputWithParams:(MTRMediaInputClusterSelectInputParams *)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self selectInputWithParams:params completion:completionHandler];
}
- (void)showInputStatusWithParams:(MTRMediaInputClusterShowInputStatusParams * _Nullable)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self showInputStatusWithParams:params completion:completionHandler];
}
- (void)showInputStatusWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self showInputStatusWithParams:nil completion:completionHandler];
}
- (void)hideInputStatusWithParams:(MTRMediaInputClusterHideInputStatusParams * _Nullable)params
                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self hideInputStatusWithParams:params completion:completionHandler];
}
- (void)hideInputStatusWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self hideInputStatusWithParams:nil completion:completionHandler];
}
- (void)renameInputWithParams:(MTRMediaInputClusterRenameInputParams *)params
            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self renameInputWithParams:params completion:completionHandler];
}

- (void)readAttributeInputListWithCompletionHandler:(void (^)(
                                                        NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInputListWithCompletion:completionHandler];
}
- (void)subscribeAttributeInputListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInputListWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeInputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInputListWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeCurrentInputWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentInputWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentInputWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentInputWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeCurrentInputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentInputWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterLowPower

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            LowPower::Commands::Sleep::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LowPowerGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(LowPowerAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, LowPowerAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, LowPowerAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::AttributeList::TypeInfo;

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRLowPowerAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(LowPowerAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::LowPowerCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterLowPower (Deprecated)

- (void)sleepWithParams:(MTRLowPowerClusterSleepParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self sleepWithParams:params completion:completionHandler];
}
- (void)sleepWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self sleepWithParams:nil completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterKeypadInput

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRKeypadInputClusterSendKeyResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputClusterSendKeyResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(KeypadInputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(KeypadInputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, KeypadInputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::AttributeList::TypeInfo;

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(KeypadInputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::KeypadInputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterKeypadInput (Deprecated)

- (void)sendKeyWithParams:(MTRKeypadInputClusterSendKeyParams *)params
        completionHandler:
            (void (^)(MTRKeypadInputClusterSendKeyResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self sendKeyWithParams:params completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterContentLauncher

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRContentLauncherClusterLaunchResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherClusterLaunchResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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);
                    }
                }
            }

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeAcceptHeaderWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptHeaderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ContentLauncherAcceptHeaderListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeSupportedStreamingProtocolsWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeSupportedStreamingProtocolsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ContentLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ContentLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::AttributeList::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ContentLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ContentLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterContentLauncher (Deprecated)

- (void)launchContentWithParams:(MTRContentLauncherClusterLaunchContentParams *)params
              completionHandler:(void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data,
                                    NSError * _Nullable error))completionHandler
{
    [self launchContentWithParams:params completion:completionHandler];
}
- (void)launchURLWithParams:(MTRContentLauncherClusterLaunchURLParams *)params
          completionHandler:
              (void (^)(MTRContentLauncherClusterLaunchResponseParams * _Nullable data, NSError * _Nullable error))completionHandler
{
    [self launchURLWithParams:params completion:completionHandler];
}

- (void)readAttributeAcceptHeaderWithCompletionHandler:(void (^)(
                                                           NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptHeaderWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptHeaderWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptHeaderWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeAcceptHeaderWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptHeaderWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeSupportedStreamingProtocolsWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedStreamingProtocolsWithCompletion:completionHandler];
}
- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSupportedStreamingProtocolsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeSupportedStreamingProtocolsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeSupportedStreamingProtocolsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeSupportedStreamingProtocolsWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeSupportedStreamingProtocolsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeSupportedStreamingProtocolsWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterAudioOutput

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

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

- (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeOutputListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputOutputListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputOutputListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::OutputList::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOutputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputOutputListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(AudioOutputOutputListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentOutputWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentOutputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AudioOutputGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AudioOutputAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, AudioOutputAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::AttributeList::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(AudioOutputAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::AudioOutputCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAudioOutput (Deprecated)

- (void)selectOutputWithParams:(MTRAudioOutputClusterSelectOutputParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self selectOutputWithParams:params completion:completionHandler];
}
- (void)renameOutputWithParams:(MTRAudioOutputClusterRenameOutputParams *)params
             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self renameOutputWithParams:params completion:completionHandler];
}

- (void)readAttributeOutputListWithCompletionHandler:(void (^)(
                                                         NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutputListWithCompletion:completionHandler];
}
- (void)subscribeAttributeOutputListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOutputListWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeOutputListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOutputListWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeCurrentOutputWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOutputWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentOutputWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentOutputWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeCurrentOutputWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOutputWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterApplicationLauncher

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherClusterLauncherResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherClusterLauncherResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeCatalogListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCatalogListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationLauncherCatalogListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeCurrentAppWithCompletion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                  NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
                }
            }

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentAppWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationLauncherCurrentAppStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationLauncherGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationLauncherAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationLauncherAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ApplicationLauncherCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterApplicationLauncher (Deprecated)

- (void)launchAppWithParams:(MTRApplicationLauncherClusterLaunchAppParams *)params
          completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                                NSError * _Nullable error))completionHandler
{
    [self launchAppWithParams:params completion:completionHandler];
}
- (void)stopAppWithParams:(MTRApplicationLauncherClusterStopAppParams *)params
        completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    [self stopAppWithParams:params completion:completionHandler];
}
- (void)hideAppWithParams:(MTRApplicationLauncherClusterHideAppParams *)params
        completionHandler:(void (^)(MTRApplicationLauncherClusterLauncherResponseParams * _Nullable data,
                              NSError * _Nullable error))completionHandler
{
    [self hideAppWithParams:params completion:completionHandler];
}

- (void)readAttributeCatalogListWithCompletionHandler:(void (^)(
                                                          NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCatalogListWithCompletion:completionHandler];
}
- (void)subscribeAttributeCatalogListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCatalogListWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeCatalogListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCatalogListWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeCurrentAppWithCompletionHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentAppWithCompletion:completionHandler];
}
- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable)value
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeCurrentAppWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicationEP * _Nullable)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeCurrentAppWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeCurrentAppWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentAppWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeCurrentAppWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(MTRApplicationLauncherClusterApplicationEP * _Nullable value,
                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentAppWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterApplicationBasic

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

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

- (void)readAttributeVendorNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationNameWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApplicationNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeProductIDWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApplicationWithCompletion:(void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                   NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApplicationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:
                                            (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicApplicationStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeStatusWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicClusterApplicationStatusEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeApplicationVersionWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApplicationVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAllowedVendorListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAllowedVendorListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicAllowedVendorListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::AttributeList::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ApplicationBasicAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ApplicationBasicCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterApplicationBasic (Deprecated)

- (void)readAttributeVendorNameWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorNameWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeVendorNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorNameWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeVendorIDWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeVendorIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorIDWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeVendorIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIDWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeApplicationNameWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationNameWithCompletion:completionHandler];
}
- (void)subscribeAttributeApplicationNameWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApplicationNameWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeApplicationNameWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationNameWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeProductIDWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithCompletion:completionHandler];
}
- (void)subscribeAttributeProductIDWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeProductIDWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeProductIDWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeProductIDWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeApplicationWithCompletionHandler:
    (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationWithCompletion:completionHandler];
}
- (void)subscribeAttributeApplicationWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:
                                           (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                               NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApplicationWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeApplicationWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(MTRApplicationBasicClusterApplicationBasicApplication * _Nullable value,
                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeStatusWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithCompletion:completionHandler];
}
- (void)subscribeAttributeStatusWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStatusWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeStatusWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeStatusWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeApplicationVersionWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationVersionWithCompletion:completionHandler];
}
- (void)subscribeAttributeApplicationVersionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApplicationVersionWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeApplicationVersionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApplicationVersionWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeAllowedVendorListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeAllowedVendorListWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeAllowedVendorListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAllowedVendorListWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeAllowedVendorListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAllowedVendorListWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterAccountLogin

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginClusterGetSetupPINResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AccountLoginGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(AccountLoginAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::AttributeList::TypeInfo;

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(AccountLoginAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::AccountLoginCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterAccountLogin (Deprecated)

- (void)getSetupPINWithParams:(MTRAccountLoginClusterGetSetupPINParams *)params
            completionHandler:(void (^)(MTRAccountLoginClusterGetSetupPINResponseParams * _Nullable data,
                                  NSError * _Nullable error))completionHandler
{
    [self getSetupPINWithParams:params completion:completionHandler];
}
- (void)loginWithParams:(MTRAccountLoginClusterLoginParams *)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self loginWithParams:params completion:completionHandler];
}
- (void)logoutWithParams:(MTRAccountLoginClusterLogoutParams * _Nullable)params
       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self logoutWithParams:params completion:completionHandler];
}
- (void)logoutWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self logoutWithParams:nil completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterElectricalMeasurement

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            ElectricalMeasurement::Commands::GetProfileInfoCommand::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
                                    completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeMeasurementTypeWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasurementTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcPowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcPowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeDcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeDcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcFrequencyMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcFrequencyMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNeutralCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNeutralCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTotalActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTotalReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeTotalApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTotalApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured1stHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured3rdHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured5thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured7thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured9thHarmonicCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasured11thHarmonicCurrentWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasured11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                             completion:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcFrequencyMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcFrequencyDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcFrequencyDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                         completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeHarmonicCurrentMultiplierWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                           completion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstantaneousVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousLineCurrentWithCompletion:(void (^)(
                                                                NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstantaneousLineCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                                     completion:
                                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousActiveCurrentWithCompletion:(void (^)(
                                                                  NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstantaneousActiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                       completion:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousReactiveCurrentWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstantaneousReactiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInstantaneousPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInstantaneousPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSagPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSwellPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcPowerMultiplierWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcPowerDivisorWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcOverloadAlarmsMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcVoltageOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcCurrentOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcActivePowerOverloadWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcActivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAcReactivePowerOverloadWithCompletion:(void (^)(
                                                               NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcReactivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                                    completion:
                                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltageWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltageWithCompletion:(void (^)(
                                                              NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                                   completion:
                                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSagWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSwellWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLineCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactiveCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReactiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltagePhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltagePhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReactivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApparentPowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerFactorPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLineCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLineCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactiveCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReactiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltagePhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltagePhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsCurrentMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsCurrentMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMinPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeActivePowerMaxPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeActivePowerMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeReactivePowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeReactivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeApparentPowerPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeApparentPowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributePowerFactorPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributePowerFactorPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                                     completion:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                                completion:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                              completion:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                               completion:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:(void (^)(
                                                                 NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                                      completion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:(void (^)(
                                                                   NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                        completion:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ElectricalMeasurementGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ElectricalMeasurementAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(ElectricalMeasurementAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::ElectricalMeasurementCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterElectricalMeasurement (Deprecated)

- (void)getProfileInfoCommandWithParams:(MTRElectricalMeasurementClusterGetProfileInfoCommandParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self getProfileInfoCommandWithParams:params completion:completionHandler];
}
- (void)getProfileInfoCommandWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self getProfileInfoCommandWithParams:nil completion:completionHandler];
}
- (void)getMeasurementProfileCommandWithParams:(MTRElectricalMeasurementClusterGetMeasurementProfileCommandParams *)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self getMeasurementProfileCommandWithParams:params completion:completionHandler];
}

- (void)readAttributeMeasurementTypeWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasurementTypeWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasurementTypeWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasurementTypeWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasurementTypeWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasurementTypeWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeDcVoltageWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcVoltageWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeDcVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeDcVoltageMinWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcVoltageMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcVoltageMinWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeDcVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMinWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeDcVoltageMaxWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcVoltageMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcVoltageMaxWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeDcVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMaxWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeDcCurrentWithCompletionHandler:(void (^)(
                                                        NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcCurrentWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeDcCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeDcCurrentMinWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcCurrentMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcCurrentMinWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeDcCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMinWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeDcCurrentMaxWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcCurrentMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcCurrentMaxWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributeDcCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMaxWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeDcPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcPowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcPowerWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeDcPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeDcPowerMinWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcPowerMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcPowerMinWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeDcPowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMinWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeDcPowerMaxWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcPowerMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcPowerMaxWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeDcPowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMaxWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeDcVoltageMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcVoltageMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcVoltageMultiplierWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeDcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageMultiplierWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeDcVoltageDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageDivisorWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeDcVoltageDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcVoltageDivisorWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeDcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcVoltageDivisorWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeDcCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcCurrentMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcCurrentMultiplierWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeDcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentMultiplierWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeDcCurrentDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentDivisorWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeDcCurrentDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcCurrentDivisorWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeDcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcCurrentDivisorWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeDcPowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcPowerMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcPowerMultiplierWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeDcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerMultiplierWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeDcPowerDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerDivisorWithCompletion:completionHandler];
}
- (void)subscribeAttributeDcPowerDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeDcPowerDivisorWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeDcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeDcPowerDivisorWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeAcFrequencyWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcFrequencyWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcFrequencyWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeAcFrequencyWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeAcFrequencyMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcFrequencyMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcFrequencyMinWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeAcFrequencyMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMinWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeAcFrequencyMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcFrequencyMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcFrequencyMaxWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeAcFrequencyMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMaxWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNeutralCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNeutralCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeNeutralCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNeutralCurrentWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNeutralCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNeutralCurrentWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeTotalActivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalActivePowerWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeTotalActivePowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTotalActivePowerWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeTotalActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalActivePowerWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeTotalReactivePowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalReactivePowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeTotalReactivePowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTotalReactivePowerWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeTotalReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalReactivePowerWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeTotalApparentPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalApparentPowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeTotalApparentPowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTotalApparentPowerWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeTotalApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTotalApparentPowerWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeMeasured1stHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured1stHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured1stHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured1stHarmonicCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeMeasured1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured1stHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeMeasured3rdHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured3rdHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured3rdHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured3rdHarmonicCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured3rdHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeMeasured5thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured5thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured5thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured5thHarmonicCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeMeasured5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured5thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeMeasured7thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured7thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured7thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured7thHarmonicCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeMeasured7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured7thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeMeasured9thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured9thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured9thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured9thHarmonicCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeMeasured9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured9thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeMeasured11thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured11thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasured11thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasured11thHarmonicCurrentWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeMeasured11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasured11thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeMeasuredPhase1stHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase1stHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase1stHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase1stHarmonicCurrentWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase1stHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase3rdHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase3rdHarmonicCurrentWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase3rdHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeMeasuredPhase5thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase5thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase5thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase5thHarmonicCurrentWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase5thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeMeasuredPhase7thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase7thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase7thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase7thHarmonicCurrentWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase7thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeMeasuredPhase9thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase9thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase9thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase9thHarmonicCurrentWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase9thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeMeasuredPhase11thHarmonicCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase11thHarmonicCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeMeasuredPhase11thHarmonicCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                              maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                   params:(MTRSubscribeParams * _Nullable)params
                                                  subscriptionEstablished:
                                                      (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                            reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeMeasuredPhase11thHarmonicCurrentWithParams:subscribeParams
                                               subscriptionEstablished:subscriptionEstablishedHandler
                                                         reportHandler:reportHandler];
}
+ (void)readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                               endpoint:(NSNumber *)endpoint
                                                                  queue:(dispatch_queue_t)queue
                                                      completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeMeasuredPhase11thHarmonicCurrentWithAttributeCache:attributeCacheContainer
                                                                 endpoint:endpoint
                                                                    queue:queue
                                                               completion:completionHandler];
}

- (void)readAttributeAcFrequencyMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcFrequencyMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcFrequencyMultiplierWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeAcFrequencyMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyMultiplierWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeAcFrequencyDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyDivisorWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcFrequencyDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcFrequencyDivisorWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeAcFrequencyDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcFrequencyDivisorWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributePowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributePowerMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerMultiplierWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributePowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerMultiplierWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributePowerDivisorWithCompletionHandler:(void (^)(
                                                           NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerDivisorWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerDivisorWithParams:subscribeParams
                           subscriptionEstablished:subscriptionEstablishedHandler
                                     reportHandler:reportHandler];
}
+ (void)readAttributePowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                           endpoint:(NSNumber *)endpoint
                                              queue:(dispatch_queue_t)queue
                                  completionHandler:
                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerDivisorWithAttributeCache:attributeCacheContainer
                                             endpoint:endpoint
                                                queue:queue
                                           completion:completionHandler];
}

- (void)readAttributeHarmonicCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeHarmonicCurrentMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeHarmonicCurrentMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeHarmonicCurrentMultiplierWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeHarmonicCurrentMultiplierWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributePhaseHarmonicCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributePhaseHarmonicCurrentMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributePhaseHarmonicCurrentMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                 params:(MTRSubscribeParams * _Nullable)params
                                                subscriptionEstablished:
                                                    (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                          reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePhaseHarmonicCurrentMultiplierWithParams:subscribeParams
                                             subscriptionEstablished:subscriptionEstablishedHandler
                                                       reportHandler:reportHandler];
}
+ (void)readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                             endpoint:(NSNumber *)endpoint
                                                                queue:(dispatch_queue_t)queue
                                                    completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributePhaseHarmonicCurrentMultiplierWithAttributeCache:attributeCacheContainer
                                                               endpoint:endpoint
                                                                  queue:queue
                                                             completion:completionHandler];
}

- (void)readAttributeInstantaneousVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstantaneousVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstantaneousVoltageWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeInstantaneousVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousVoltageWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeInstantaneousLineCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousLineCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstantaneousLineCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                           params:(MTRSubscribeParams * _Nullable)params
                                          subscriptionEstablished:
                                              (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstantaneousLineCurrentWithParams:subscribeParams
                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                 reportHandler:reportHandler];
}
+ (void)readAttributeInstantaneousLineCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                       endpoint:(NSNumber *)endpoint
                                                          queue:(dispatch_queue_t)queue
                                              completionHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousLineCurrentWithAttributeCache:attributeCacheContainer
                                                         endpoint:endpoint
                                                            queue:queue
                                                       completion:completionHandler];
}

- (void)readAttributeInstantaneousActiveCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousActiveCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstantaneousActiveCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                                             params:(MTRSubscribeParams * _Nullable)params
                                            subscriptionEstablished:
                                                (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                      reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstantaneousActiveCurrentWithParams:subscribeParams
                                         subscriptionEstablished:subscriptionEstablishedHandler
                                                   reportHandler:reportHandler];
}
+ (void)readAttributeInstantaneousActiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                         endpoint:(NSNumber *)endpoint
                                                            queue:(dispatch_queue_t)queue
                                                completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousActiveCurrentWithAttributeCache:attributeCacheContainer
                                                           endpoint:endpoint
                                                              queue:queue
                                                         completion:completionHandler];
}

- (void)readAttributeInstantaneousReactiveCurrentWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousReactiveCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstantaneousReactiveCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstantaneousReactiveCurrentWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeInstantaneousReactiveCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousReactiveCurrentWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeInstantaneousPowerWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousPowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeInstantaneousPowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInstantaneousPowerWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeInstantaneousPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInstantaneousPowerWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeRmsVoltageWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeRmsVoltageMinWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMinWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRmsVoltageMaxWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMaxWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRmsCurrentWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeRmsCurrentMinWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMinWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRmsCurrentMaxWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMaxWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeActivePowerWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeActivePowerMinWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMinWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMinWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMinWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeActivePowerMaxWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMaxWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMaxWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMaxWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeReactivePowerWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeReactivePowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReactivePowerWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeReactivePowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeApparentPowerWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerWithCompletion:completionHandler];
}
- (void)subscribeAttributeApparentPowerWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApparentPowerWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeApparentPowerWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributePowerFactorWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerFactorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerFactorWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributePowerFactorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodWithCompletion:completionHandler];
}
- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _Nonnull)value
                                                           params:(MTRWriteParams * _Nullable)params
                                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsVoltageMeasurementPeriodWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeAverageRmsUnderVoltageCounterWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterWithCompletion:completionHandler];
}
- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAverageRmsUnderVoltageCounterWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnull)value
                                                      params:(MTRWriteParams * _Nullable)params
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAverageRmsUnderVoltageCounterWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeAverageRmsUnderVoltageCounterWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsUnderVoltageCounterWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodWithCompletion:completionHandler];
}
- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsExtremeOverVoltagePeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                                    params:(MTRWriteParams * _Nullable)params
                                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsExtremeOverVoltagePeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeOverVoltagePeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeOverVoltagePeriodWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodWithCompletion:completionHandler];
}
- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsExtremeUnderVoltagePeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsExtremeUnderVoltagePeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeUnderVoltagePeriodWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeRmsVoltageSagPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodWithCompletion:completionHandler];
}
- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsVoltageSagPeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsVoltageSagPeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSagPeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSagPeriodWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSagPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsVoltageSwellPeriodWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodWithCompletion:completionHandler];
}
- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsVoltageSwellPeriodWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRmsVoltageSwellPeriodWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSwellPeriodWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSwellPeriodWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSwellPeriodWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeAcVoltageMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcVoltageMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcVoltageMultiplierWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcVoltageMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageMultiplierWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAcVoltageDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageDivisorWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeAcVoltageDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcVoltageDivisorWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeAcVoltageDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageDivisorWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeAcCurrentMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcCurrentMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcCurrentMultiplierWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcCurrentMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentMultiplierWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAcCurrentDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentDivisorWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeAcCurrentDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcCurrentDivisorWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeAcCurrentDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentDivisorWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeAcPowerMultiplierWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerMultiplierWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcPowerMultiplierWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcPowerMultiplierWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeAcPowerMultiplierWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerMultiplierWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeAcPowerDivisorWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerDivisorWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcPowerDivisorWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcPowerDivisorWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeAcPowerDivisorWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcPowerDivisorWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeOverloadAlarmsMaskWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeOverloadAlarmsMaskWithCompletion:completionHandler];
}
- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOverloadAlarmsMaskWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOverloadAlarmsMaskWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOverloadAlarmsMaskWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOverloadAlarmsMaskWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOverloadAlarmsMaskWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeVoltageOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeVoltageOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeVoltageOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVoltageOverloadWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVoltageOverloadWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeCurrentOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeCurrentOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCurrentOverloadWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCurrentOverloadWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeAcOverloadAlarmsMaskWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeAcOverloadAlarmsMaskWithCompletion:completionHandler];
}
- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAcOverloadAlarmsMaskWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeAcOverloadAlarmsMaskWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeAcOverloadAlarmsMaskWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcOverloadAlarmsMaskWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeAcOverloadAlarmsMaskWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcOverloadAlarmsMaskWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcVoltageOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcVoltageOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcVoltageOverloadWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeAcVoltageOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcVoltageOverloadWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeAcCurrentOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcCurrentOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcCurrentOverloadWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeAcCurrentOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcCurrentOverloadWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeAcActivePowerOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeAcActivePowerOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcActivePowerOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcActivePowerOverloadWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeAcActivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcActivePowerOverloadWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeAcReactivePowerOverloadWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeAcReactivePowerOverloadWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcReactivePowerOverloadWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                                          params:(MTRSubscribeParams * _Nullable)params
                                         subscriptionEstablished:
                                             (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                   reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcReactivePowerOverloadWithParams:subscribeParams
                                      subscriptionEstablished:subscriptionEstablishedHandler
                                                reportHandler:reportHandler];
}
+ (void)readAttributeAcReactivePowerOverloadWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                      endpoint:(NSNumber *)endpoint
                                                         queue:(dispatch_queue_t)queue
                                             completionHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcReactivePowerOverloadWithAttributeCache:attributeCacheContainer
                                                        endpoint:endpoint
                                                           queue:queue
                                                      completion:completionHandler];
}

- (void)readAttributeAverageRmsOverVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsOverVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsOverVoltageWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeAverageRmsUnderVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsUnderVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsUnderVoltageWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeRmsExtremeOverVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeOverVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeOverVoltageWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeOverVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltageWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeRmsExtremeUnderVoltageWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltageWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeUnderVoltageWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                                         params:(MTRSubscribeParams * _Nullable)params
                                        subscriptionEstablished:
                                            (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                  reportHandler:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeUnderVoltageWithParams:subscribeParams
                                     subscriptionEstablished:subscriptionEstablishedHandler
                                               reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeUnderVoltageWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                     endpoint:(NSNumber *)endpoint
                                                        queue:(dispatch_queue_t)queue
                                            completionHandler:
                                                (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltageWithAttributeCache:attributeCacheContainer
                                                       endpoint:endpoint
                                                          queue:queue
                                                     completion:completionHandler];
}

- (void)readAttributeRmsVoltageSagWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSagWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSagWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSagWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeRmsVoltageSwellWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSwellWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSwellWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSwellWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeLineCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeLineCurrentPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLineCurrentPhaseBWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeLineCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseBWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeActiveCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveCurrentPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveCurrentPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeActiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeReactiveCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeReactiveCurrentPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReactiveCurrentPhaseBWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeReactiveCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseBWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeRmsVoltagePhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseBWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRmsVoltagePhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltagePhaseBWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltagePhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseBWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeRmsVoltageMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMinPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMinPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsVoltageMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMaxPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMaxPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsCurrentPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseBWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRmsCurrentPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentPhaseBWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseBWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeRmsCurrentMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMinPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMinPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsCurrentMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMaxPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMaxPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeActivePowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerPhaseBWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseBWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeActivePowerMinPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMinPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMinPhaseBWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMinPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseBWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeActivePowerMaxPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMaxPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMaxPhaseBWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMaxPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseBWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeReactivePowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeReactivePowerPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReactivePowerPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeReactivePowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeApparentPowerPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeApparentPowerPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApparentPowerPhaseBWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeApparentPowerPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseBWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributePowerFactorPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerFactorPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerFactorPhaseBWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePowerFactorPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseBWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsOverVoltageCounterPhaseBWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseBWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                      params:(MTRSubscribeParams * _Nullable)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsUnderVoltageCounterPhaseBWithParams:subscribeParams
                                                  subscriptionEstablished:subscriptionEstablishedHandler
                                                            reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                         completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseBWithAttributeCache:attributeCacheContainer
                                                                    endpoint:endpoint
                                                                       queue:queue
                                                                  completion:completionHandler];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                    params:(MTRSubscribeParams * _Nullable)params
                                                   subscriptionEstablished:
                                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                             reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeOverVoltagePeriodPhaseBWithParams:subscribeParams
                                                subscriptionEstablished:subscriptionEstablishedHandler
                                                          reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                       completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseBWithAttributeCache:attributeCacheContainer
                                                                  endpoint:endpoint
                                                                     queue:queue
                                                                completion:completionHandler];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseBWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSagPeriodPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSagPeriodPhaseBWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseBWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseBWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseBWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseBWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSwellPeriodPhaseBWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseBWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeLineCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeLineCurrentPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLineCurrentPhaseCWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeLineCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLineCurrentPhaseCWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeActiveCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeActiveCurrentPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActiveCurrentPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeActiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActiveCurrentPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeReactiveCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeReactiveCurrentPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReactiveCurrentPhaseCWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeReactiveCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactiveCurrentPhaseCWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeRmsVoltagePhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseCWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRmsVoltagePhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltagePhaseCWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltagePhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltagePhaseCWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeRmsVoltageMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMinPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMinPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMinPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsVoltageMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageMaxPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageMaxPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageMaxPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsCurrentPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseCWithCompletion:completionHandler];
}
- (void)
    subscribeAttributeRmsCurrentPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentPhaseCWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentPhaseCWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeRmsCurrentMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMinPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMinPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMinPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeRmsCurrentMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsCurrentMaxPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsCurrentMaxPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeRmsCurrentMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsCurrentMaxPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeActivePowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerPhaseCWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerPhaseCWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeActivePowerMinPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMinPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMinPhaseCWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMinPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMinPhaseCWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeActivePowerMaxPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeActivePowerMaxPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeActivePowerMaxPhaseCWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeActivePowerMaxPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeActivePowerMaxPhaseCWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeReactivePowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeReactivePowerPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeReactivePowerPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeReactivePowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeReactivePowerPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeApparentPowerPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeApparentPowerPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeApparentPowerPhaseCWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeApparentPowerPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeApparentPowerPhaseCWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributePowerFactorPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributePowerFactorPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributePowerFactorPhaseCWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributePowerFactorPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributePowerFactorPhaseCWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                           params:(MTRSubscribeParams * _Nullable)params
                                                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)
                                                                                      subscriptionEstablishedHandler
                                                                    reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                      NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithParams:subscribeParams
                                                       subscriptionEstablished:subscriptionEstablishedHandler
                                                                 reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:
            (MTRAttributeCacheContainer *)attributeCacheContainer
                                                                       endpoint:(NSNumber *)endpoint
                                                                          queue:(dispatch_queue_t)queue
                                                              completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithAttributeCache:attributeCacheContainer
                                                                         endpoint:endpoint
                                                                            queue:queue
                                                                       completion:completionHandler];
}

- (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsOverVoltageCounterPhaseCWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsOverVoltageCounterPhaseCWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                      params:(MTRSubscribeParams * _Nullable)params
                                                     subscriptionEstablished:
                                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                               reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAverageRmsUnderVoltageCounterPhaseCWithParams:subscribeParams
                                                  subscriptionEstablished:subscriptionEstablishedHandler
                                                            reportHandler:reportHandler];
}
+ (void)readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                  endpoint:(NSNumber *)endpoint
                                                                     queue:(dispatch_queue_t)queue
                                                         completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeAverageRmsUnderVoltageCounterPhaseCWithAttributeCache:attributeCacheContainer
                                                                    endpoint:endpoint
                                                                       queue:queue
                                                                  completion:completionHandler];
}

- (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                    params:(MTRSubscribeParams * _Nullable)params
                                                   subscriptionEstablished:
                                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                             reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                               NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeOverVoltagePeriodPhaseCWithParams:subscribeParams
                                                subscriptionEstablished:subscriptionEstablishedHandler
                                                          reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                endpoint:(NSNumber *)endpoint
                                                                   queue:(dispatch_queue_t)queue
                                                       completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeOverVoltagePeriodPhaseCWithAttributeCache:attributeCacheContainer
                                                                  endpoint:endpoint
                                                                     queue:queue
                                                                completion:completionHandler];
}

- (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                     params:(MTRSubscribeParams * _Nullable)params
                                                    subscriptionEstablished:
                                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                              reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                                NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithParams:subscribeParams
                                                 subscriptionEstablished:subscriptionEstablishedHandler
                                                           reportHandler:reportHandler];
}
+ (void)readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                                 endpoint:(NSNumber *)endpoint
                                                                    queue:(dispatch_queue_t)queue
                                                        completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsExtremeUnderVoltagePeriodPhaseCWithAttributeCache:attributeCacheContainer
                                                                   endpoint:endpoint
                                                                      queue:queue
                                                                 completion:completionHandler];
}

- (void)readAttributeRmsVoltageSagPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSagPeriodPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                                            params:(MTRSubscribeParams * _Nullable)params
                                           subscriptionEstablished:
                                               (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                     reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSagPeriodPhaseCWithParams:subscribeParams
                                        subscriptionEstablished:subscriptionEstablishedHandler
                                                  reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                        endpoint:(NSNumber *)endpoint
                                                           queue:(dispatch_queue_t)queue
                                               completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSagPeriodPhaseCWithAttributeCache:attributeCacheContainer
                                                          endpoint:endpoint
                                                             queue:queue
                                                        completion:completionHandler];
}

- (void)readAttributeRmsVoltageSwellPeriodPhaseCWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseCWithCompletion:completionHandler];
}
- (void)subscribeAttributeRmsVoltageSwellPeriodPhaseCWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                                              params:(MTRSubscribeParams * _Nullable)params
                                             subscriptionEstablished:
                                                 (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                       reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRmsVoltageSwellPeriodPhaseCWithParams:subscribeParams
                                          subscriptionEstablished:subscriptionEstablishedHandler
                                                    reportHandler:reportHandler];
}
+ (void)readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                          endpoint:(NSNumber *)endpoint
                                                             queue:(dispatch_queue_t)queue
                                                 completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                       NSError * _Nullable error))completionHandler
{
    [self readAttributeRmsVoltageSwellPeriodPhaseCWithAttributeCache:attributeCacheContainer
                                                            endpoint:endpoint
                                                               queue:queue
                                                          completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

@implementation MTRBaseClusterTestCluster

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

        _device = device;
        _endpoint = [endpointID 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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            TestCluster::Commands::Test::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            TestCluster::Commands::TestNotHandled::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestSpecificResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestSpecificResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            TestCluster::Commands::TestSpecific::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            chip::Optional<uint16_t> timedInvokeTimeoutMs;
            ListFreer listFreer;
            TestCluster::Commands::TestUnknownCommand::Type request;
            if (params != nil) {
                if (params.timedInvokeTimeoutMs != nil) {
                    timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue);
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestAddArgumentsResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestSimpleArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestStructArrayArgumentResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterBooleanResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterBooleanResponseCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestListInt8UReverseResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestEnumsResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestEnumsResponseCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;
                    }
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestComplexNullableOptionalResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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();
                        }
                    }
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterSimpleStructResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterSimpleStructResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
                                         completion:(MTRStatusCompletion)completion
{
    // Make a copy of params before we go async.
    params = [params copy];
    auto * bridge = new MTRCommandSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable value, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestEmitTestEventResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.InvokeCommand(request, bridge, successCb, failureCb, timedInvokeTimeoutMs);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (void)readAttributeBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Boolean::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap8AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap8AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap8::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap8AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap8AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap16AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap16AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap16::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap16AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap16AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap32AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap32AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap32::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap32AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap32AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap64AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterBitmap64AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Bitmap64::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterBitmap64AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterBitmap64AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int16u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int24u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int32u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int40u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int48u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int56u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int64u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int8s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int16s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int24s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int32s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int40s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int48s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int56s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Int64s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Enum8::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                                  completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Enum16::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFloatAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, FloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRFloatAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRFloatAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(FloatAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoubleAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoubleAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRDoubleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DoubleAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRDoubleAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRDoubleAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(DoubleAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::OctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(OctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListInt8uWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterListInt8uListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterListInt8uListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListInt8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                                      completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListInt8uListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterListInt8uListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListOctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterListOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeListStructOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListStructOctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListStructOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterListStructOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeLongOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTROctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, OctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTROctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::LongOctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTROctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTROctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(OctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::CharString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeLongCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, CharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::LongCharString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeLongCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(CharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEpochUsWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EpochUs::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEpochUsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                                    completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeEpochSWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EpochS::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEpochSWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                                   completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeVendorIdWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRVendorIdAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, VendorIdAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRVendorIdAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::VendorId::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRVendorIdAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRVendorIdAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(VendorIdAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListNullablesAndOptionalsStructWithCompletion:(void (^)(NSArray * _Nullable value,
                                                                       NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge
                = static_cast<MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished,
                nil, params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListNullablesAndOptionalsStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                            completion:(void (^)(NSArray * _Nullable value,
                                                                           NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterListNullablesAndOptionalsStructListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterSimpleEnumAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterClusterSimpleEnumAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::EnumAttr::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                                     completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeStructAttrWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                  NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterStructAttrStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterStructAttrStructAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::StructAttr::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeStructAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterStructAttrStructAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt8s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::RangeRestrictedInt16s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                                  completion:
                                                      (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeListLongOctetStringWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterListLongOctetStringListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, 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];
    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb, params.filterByFabric);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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();
                }
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ListFabricScoped::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeListFabricScopedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterListFabricScopedListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeTimedWriteBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::TimedWriteBoolean::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeTimedWriteBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                              completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneralErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::GeneralErrorBoolean::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneralErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterErrorBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ClusterErrorBoolean::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeUnsupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, BooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::Unsupported::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeUnsupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                        completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(BooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBooleanWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableBooleanAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableBooleanAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableBooleanAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBoolean::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableBooleanAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableBooleanAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableBooleanAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap8AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap8AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap8::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap8AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap16AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap16AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap16::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap16AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap32WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap32AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap32AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap32::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap32AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableBitmap64WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap64AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterNullableBitmap64AttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableBitmap64::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterNullableBitmap64AttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt16uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt16u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt24uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt24u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt32uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt32u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt40uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt40u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt48uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt48u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt56uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt56u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt64uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt64u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt8sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt8s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt16sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt16s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt24sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt24s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt32sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt32sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt32sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt32sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt32s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt32sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt32sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt32sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt40sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt40s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt48sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt48s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt56sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt56s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableInt64sWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt64sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt64sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt64sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableInt64s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt64sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt64sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt64sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnum8WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnum8::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnum16WithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnum16::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableFloatSingleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableFloatAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableFloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableFloatAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableFloatAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableFloatAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableFloatAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableFloatAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableFloatAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableFloatDoubleWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoubleAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableDoubleAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableDoubleAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableDoubleAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableDoubleAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableDoubleAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableDoubleAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableDoubleAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableOctetStringWithCompletion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableOctetStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableOctetStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableOctetStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableOctetString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableOctetStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableOctetStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableOctetStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableCharStringWithCompletion:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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];
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableCharStringAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableCharStringAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableCharStringAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableCharString::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableCharStringAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                               completion:
                                                   (void (^)(NSString * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableCharStringAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableCharStringAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableEnumAttrWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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);
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableEnumAttr::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                             completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(NullableTestClusterClusterSimpleEnumAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNullableStructWithCompletion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                      NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableStruct::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                          NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterNullableStructStructAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeNullableRangeRestrictedInt8uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt8sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt8sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt8sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt8sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt8s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt8sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                         completion:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt8sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt8sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt16uWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeNullableRangeRestrictedInt16sWithCompletion:(void (^)(NSNumber * _Nullable value,
                                                                     NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;
            }

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRNullableInt16sAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, NullableInt16sAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRNullableInt16sAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::NullableRangeRestrictedInt16s::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRNullableInt16sAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeNullableRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                          completion:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completion
{
    auto * bridge = new MTRNullableInt16sAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(NullableInt16sAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeWriteOnlyInt8uWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

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

    auto * bridge = new MTRDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completion(error);
        },
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            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;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt8uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int8uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt8uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::WriteOnlyInt8u::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt8uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeWriteOnlyInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                           completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt8uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int8uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                                 completion:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session,
            TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb,
            MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                                completion:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(
        ^(TestClusterAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) {
            if (attributeCacheContainer.cppAttributeCache) {
                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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
                if (err == CHIP_NO_ERROR) {
                    successCb(bridge, value);
                }
                return err;
            }
            return CHIP_ERROR_NOT_FOUND;
        });
}

- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, TestClusterAttributeListListAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::AttributeList::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil,
                params.filterByFabric, !params.replaceExistingSubscriptions, chip::NullOptional,
                [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                          completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRTestClusterAttributeListListAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(TestClusterAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt32uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int32uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt32uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt32uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                       completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(self.callbackQueue, completion,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            return cppCluster.ReadAttribute<TypeInfo>(bridge, successCb, failureCb);
        });
    std::move(*bridge).DispatchAction(self.device);
}

- (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];
    auto * bridge = new MTRInt16uAttributeCallbackSubscriptionBridge(
        self.callbackQueue, reportHandler,
        ^(ExchangeManager & exchangeManager, const SessionHandle & session, Int16uAttributeCallback successCb,
            MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
            auto * typedBridge = static_cast<MTRInt16uAttributeCallbackSubscriptionBridge *>(bridge);
            if (!params.resubscribeIfLost) {
                // We don't support disabling auto-resubscribe.
                return CHIP_ERROR_INVALID_ARGUMENT;
            }
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;

            chip::Controller::TestClusterCluster cppCluster(exchangeManager, session, self->_endpoint);
            CHIP_ERROR err = cppCluster.SubscribeAttribute<TypeInfo>(bridge, successCb, failureCb,
                [params.minInterval unsignedShortValue], [params.maxInterval unsignedShortValue],
                MTRInt16uAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished, nil, params.filterByFabric,
                !params.replaceExistingSubscriptions, chip::NullOptional, [typedBridge](void) { typedBridge->OnDone(); });
            if (err == CHIP_NO_ERROR) {
                // Now that we kicked off the subscribe, flag our callback bridge
                // to stay alive until we get an OnDone.
                typedBridge->KeepAliveOnCallback();
            }
            return err;
        },
        subscriptionEstablished);
    std::move(*bridge).DispatchAction(self.device);
}

+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                            completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion
{
    auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion);
    std::move(*bridge).DispatchLocalAction(^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) {
        if (attributeCacheContainer.cppAttributeCache) {
            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 = attributeCacheContainer.cppAttributeCache->Get<TypeInfo>(path, value);
            if (err == CHIP_NO_ERROR) {
                successCb(bridge, value);
            }
            return err;
        }
        return CHIP_ERROR_NOT_FOUND;
    });
}

@end

@implementation MTRBaseClusterTestCluster (Deprecated)

- (void)testWithParams:(MTRTestClusterClusterTestParams * _Nullable)params completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testWithParams:params completion:completionHandler];
}
- (void)testWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testWithParams:nil completion:completionHandler];
}
- (void)testNotHandledWithParams:(MTRTestClusterClusterTestNotHandledParams * _Nullable)params
               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testNotHandledWithParams:params completion:completionHandler];
}
- (void)testNotHandledWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testNotHandledWithParams:nil completion:completionHandler];
}
- (void)testSpecificWithParams:(MTRTestClusterClusterTestSpecificParams * _Nullable)params
             completionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                   NSError * _Nullable error))completionHandler
{
    [self testSpecificWithParams:params completion:completionHandler];
}
- (void)testSpecificWithCompletionHandler:(void (^)(MTRTestClusterClusterTestSpecificResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    [self testSpecificWithParams:nil completion:completionHandler];
}
- (void)testUnknownCommandWithParams:(MTRTestClusterClusterTestUnknownCommandParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testUnknownCommandWithParams:params completion:completionHandler];
}
- (void)testUnknownCommandWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self testUnknownCommandWithParams:nil completion:completionHandler];
}
- (void)testAddArgumentsWithParams:(MTRTestClusterClusterTestAddArgumentsParams *)params
                 completionHandler:(void (^)(MTRTestClusterClusterTestAddArgumentsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self testAddArgumentsWithParams:params completion:completionHandler];
}
- (void)testSimpleArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleArgumentRequestParams *)params
                          completionHandler:(void (^)(MTRTestClusterClusterTestSimpleArgumentResponseParams * _Nullable data,
                                                NSError * _Nullable error))completionHandler
{
    [self testSimpleArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testStructArrayArgumentRequestWithParams:(MTRTestClusterClusterTestStructArrayArgumentRequestParams *)params
                               completionHandler:
                                   (void (^)(MTRTestClusterClusterTestStructArrayArgumentResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self testStructArrayArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testStructArgumentRequestWithParams:(MTRTestClusterClusterTestStructArgumentRequestParams *)params
                          completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                NSError * _Nullable error))completionHandler
{
    [self testStructArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testNestedStructArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructArgumentRequestParams *)params
                                completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                      NSError * _Nullable error))completionHandler
{
    [self testNestedStructArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testListStructArgumentRequestWithParams:(MTRTestClusterClusterTestListStructArgumentRequestParams *)params
                              completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                    NSError * _Nullable error))completionHandler
{
    [self testListStructArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testListInt8UArgumentRequestWithParams:(MTRTestClusterClusterTestListInt8UArgumentRequestParams *)params
                             completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                   NSError * _Nullable error))completionHandler
{
    [self testListInt8UArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testNestedStructListArgumentRequestWithParams:(MTRTestClusterClusterTestNestedStructListArgumentRequestParams *)params
                                    completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                          NSError * _Nullable error))completionHandler
{
    [self testNestedStructListArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testListNestedStructListArgumentRequestWithParams:
            (MTRTestClusterClusterTestListNestedStructListArgumentRequestParams *)params
                                        completionHandler:(void (^)(MTRTestClusterClusterBooleanResponseParams * _Nullable data,
                                                              NSError * _Nullable error))completionHandler
{
    [self testListNestedStructListArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testListInt8UReverseRequestWithParams:(MTRTestClusterClusterTestListInt8UReverseRequestParams *)params
                            completionHandler:(void (^)(MTRTestClusterClusterTestListInt8UReverseResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completionHandler
{
    [self testListInt8UReverseRequestWithParams:params completion:completionHandler];
}
- (void)testEnumsRequestWithParams:(MTRTestClusterClusterTestEnumsRequestParams *)params
                 completionHandler:(void (^)(MTRTestClusterClusterTestEnumsResponseParams * _Nullable data,
                                       NSError * _Nullable error))completionHandler
{
    [self testEnumsRequestWithParams:params completion:completionHandler];
}
- (void)testNullableOptionalRequestWithParams:(MTRTestClusterClusterTestNullableOptionalRequestParams * _Nullable)params
                            completionHandler:(void (^)(MTRTestClusterClusterTestNullableOptionalResponseParams * _Nullable data,
                                                  NSError * _Nullable error))completionHandler
{
    [self testNullableOptionalRequestWithParams:params completion:completionHandler];
}
- (void)testComplexNullableOptionalRequestWithParams:(MTRTestClusterClusterTestComplexNullableOptionalRequestParams *)params
                                   completionHandler:
                                       (void (^)(MTRTestClusterClusterTestComplexNullableOptionalResponseParams * _Nullable data,
                                           NSError * _Nullable error))completionHandler
{
    [self testComplexNullableOptionalRequestWithParams:params completion:completionHandler];
}
- (void)simpleStructEchoRequestWithParams:(MTRTestClusterClusterSimpleStructEchoRequestParams *)params
                        completionHandler:(void (^)(MTRTestClusterClusterSimpleStructResponseParams * _Nullable data,
                                              NSError * _Nullable error))completionHandler
{
    [self simpleStructEchoRequestWithParams:params completion:completionHandler];
}
- (void)timedInvokeRequestWithParams:(MTRTestClusterClusterTimedInvokeRequestParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self timedInvokeRequestWithParams:params completion:completionHandler];
}
- (void)timedInvokeRequestWithCompletionHandler:(MTRStatusCompletion)completionHandler
{
    [self timedInvokeRequestWithParams:nil completion:completionHandler];
}
- (void)testSimpleOptionalArgumentRequestWithParams:(MTRTestClusterClusterTestSimpleOptionalArgumentRequestParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self testSimpleOptionalArgumentRequestWithParams:params completion:completionHandler];
}
- (void)testEmitTestEventRequestWithParams:(MTRTestClusterClusterTestEmitTestEventRequestParams *)params
                         completionHandler:(void (^)(MTRTestClusterClusterTestEmitTestEventResponseParams * _Nullable data,
                                               NSError * _Nullable error))completionHandler
{
    [self testEmitTestEventRequestWithParams:params completion:completionHandler];
}
- (void)testEmitTestFabricScopedEventRequestWithParams:(MTRTestClusterClusterTestEmitTestFabricScopedEventRequestParams *)params
                                     completionHandler:
                                         (void (^)(
                                             MTRTestClusterClusterTestEmitTestFabricScopedEventResponseParams * _Nullable data,
                                             NSError * _Nullable error))completionHandler
{
    [self testEmitTestFabricScopedEventRequestWithParams:params completion:completionHandler];
}

- (void)readAttributeBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBooleanWithCompletion:completionHandler];
}
- (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBooleanWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBooleanWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBooleanWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBooleanWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBooleanWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap8WithCompletion:completionHandler];
}
- (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap8WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap8WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBitmap8WithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBitmap8WithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap8WithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeBitmap16WithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap16WithCompletion:completionHandler];
}
- (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap16WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap16WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBitmap16WithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBitmap16WithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap16WithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeBitmap32WithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap32WithCompletion:completionHandler];
}
- (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap32WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap32WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBitmap32WithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBitmap32WithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap32WithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeBitmap64WithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap64WithCompletion:completionHandler];
}
- (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap64WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeBitmap64WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeBitmap64WithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeBitmap64WithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeBitmap64WithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt8uWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16uWithCompletion:completionHandler];
}
- (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt16uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt16uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt16uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt16uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24uWithCompletion:completionHandler];
}
- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt24uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt24uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt24uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt24uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32uWithCompletion:completionHandler];
}
- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt32uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt32uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt32uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt32uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40uWithCompletion:completionHandler];
}
- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt40uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt40uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt40uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt40uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48uWithCompletion:completionHandler];
}
- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt48uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt48uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt48uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt48uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56uWithCompletion:completionHandler];
}
- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt56uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt56uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt56uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt56uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64uWithCompletion:completionHandler];
}
- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt64uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt64uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt64uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt64uWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64uWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8sWithCompletion:completionHandler];
}
- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt8sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt8sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt8sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt8sWithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt8sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16sWithCompletion:completionHandler];
}
- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt16sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt16sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt16sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt16sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt16sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24sWithCompletion:completionHandler];
}
- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt24sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt24sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt24sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt24sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt24sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32sWithCompletion:completionHandler];
}
- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt32sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt32sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt32sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt32sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt32sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40sWithCompletion:completionHandler];
}
- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt40sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt40sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt40sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt40sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt40sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48sWithCompletion:completionHandler];
}
- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt48sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt48sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt48sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt48sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt48sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56sWithCompletion:completionHandler];
}
- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt56sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt56sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt56sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt56sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt56sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64sWithCompletion:completionHandler];
}
- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt64sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeInt64sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeInt64sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeInt64sWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeInt64sWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeEnum8WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum8WithCompletion:completionHandler];
}
- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnum8WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value
                              params:(MTRWriteParams * _Nullable)params
                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnum8WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnum8WithMinInterval:(NSNumber * _Nonnull)minInterval
                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                        params:(MTRSubscribeParams * _Nullable)params
                       subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                 reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnum8WithParams:subscribeParams
                    subscriptionEstablished:subscriptionEstablishedHandler
                              reportHandler:reportHandler];
}
+ (void)readAttributeEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                    endpoint:(NSNumber *)endpoint
                                       queue:(dispatch_queue_t)queue
                           completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum8WithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum16WithCompletion:completionHandler];
}
- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnum16WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnum16WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnum16WithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnum16WithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnum16WithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeFloatSingleWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatSingleWithCompletion:completionHandler];
}
- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFloatSingleWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFloatSingleWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeFloatSingleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFloatSingleWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatSingleWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatDoubleWithCompletion:completionHandler];
}
- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFloatDoubleWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeFloatDoubleWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeFloatDoubleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFloatDoubleWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFloatDoubleWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeOctetStringWithCompletionHandler:(void (^)(
                                                          NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeOctetStringWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeOctetStringWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeListInt8uWithCompletionHandler:(void (^)(
                                                        NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value
                                  params:(MTRWriteParams * _Nullable)params
                       completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeListInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                       maxInterval:(NSNumber * _Nonnull)maxInterval
                                            params:(MTRSubscribeParams * _Nullable)params
                           subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                     reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListInt8uWithParams:subscribeParams
                        subscriptionEstablished:subscriptionEstablishedHandler
                                  reportHandler:reportHandler];
}
+ (void)readAttributeListInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                        endpoint:(NSNumber *)endpoint
                                           queue:(dispatch_queue_t)queue
                               completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListInt8uWithAttributeCache:attributeCacheContainer
                                          endpoint:endpoint
                                             queue:queue
                                        completion:completionHandler];
}

- (void)readAttributeListOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeListOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeListOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListOctetStringWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeListOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListOctetStringWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeListStructOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeListStructOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListStructOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListStructOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeListStructOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListStructOctetStringWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeListStructOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListStructOctetStringWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeLongOctetStringWithCompletionHandler:(void (^)(
                                                              NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLongOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLongOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLongOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLongOctetStringWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongOctetStringWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeCharStringWithCompletionHandler:(void (^)(
                                                         NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCharStringWithCompletion:completionHandler];
}
- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeCharStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeCharStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeCharStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeCharStringWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeCharStringWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeLongCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeLongCharStringWithCompletion:completionHandler];
}
- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLongCharStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeLongCharStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeLongCharStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeLongCharStringWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeLongCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeLongCharStringWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeEpochUsWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochUsWithCompletion:completionHandler];
}
- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEpochUsWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value
                                params:(MTRWriteParams * _Nullable)params
                     completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEpochUsWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEpochUsWithMinInterval:(NSNumber * _Nonnull)minInterval
                                     maxInterval:(NSNumber * _Nonnull)maxInterval
                                          params:(MTRSubscribeParams * _Nullable)params
                         subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                   reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEpochUsWithParams:subscribeParams
                      subscriptionEstablished:subscriptionEstablishedHandler
                                reportHandler:reportHandler];
}
+ (void)readAttributeEpochUsWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                      endpoint:(NSNumber *)endpoint
                                         queue:(dispatch_queue_t)queue
                             completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochUsWithAttributeCache:attributeCacheContainer
                                        endpoint:endpoint
                                           queue:queue
                                      completion:completionHandler];
}

- (void)readAttributeEpochSWithCompletionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochSWithCompletion:completionHandler];
}
- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEpochSWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value
                               params:(MTRWriteParams * _Nullable)params
                    completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEpochSWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEpochSWithMinInterval:(NSNumber * _Nonnull)minInterval
                                    maxInterval:(NSNumber * _Nonnull)maxInterval
                                         params:(MTRSubscribeParams * _Nullable)params
                        subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                  reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEpochSWithParams:subscribeParams
                     subscriptionEstablished:subscriptionEstablishedHandler
                               reportHandler:reportHandler];
}
+ (void)readAttributeEpochSWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                     endpoint:(NSNumber *)endpoint
                                        queue:(dispatch_queue_t)queue
                            completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEpochSWithAttributeCache:attributeCacheContainer endpoint:endpoint queue:queue completion:completionHandler];
}

- (void)readAttributeVendorIdWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIdWithCompletion:completionHandler];
}
- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeVendorIdWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeVendorIdWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeVendorIdWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeVendorIdWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeVendorIdWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeVendorIdWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeListNullablesAndOptionalsStructWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeListNullablesAndOptionalsStructWithCompletion:completionHandler];
}
- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull)value
                                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListNullablesAndOptionalsStructWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnull)value
                                                        params:(MTRWriteParams * _Nullable)params
                                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListNullablesAndOptionalsStructWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeListNullablesAndOptionalsStructWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                  params:(MTRSubscribeParams * _Nullable)params
                                                 subscriptionEstablished:
                                                     (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                           reportHandler:(void (^)(NSArray * _Nullable value,
                                                                             NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListNullablesAndOptionalsStructWithParams:subscribeParams
                                              subscriptionEstablished:subscriptionEstablishedHandler
                                                        reportHandler:reportHandler];
}
+ (void)readAttributeListNullablesAndOptionalsStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                              endpoint:(NSNumber *)endpoint
                                                                 queue:(dispatch_queue_t)queue
                                                     completionHandler:(void (^)(NSArray * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeListNullablesAndOptionalsStructWithAttributeCache:attributeCacheContainer
                                                                endpoint:endpoint
                                                                   queue:queue
                                                              completion:completionHandler];
}

- (void)readAttributeEnumAttrWithCompletionHandler:(void (^)(
                                                       NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnumAttrWithCompletion:completionHandler];
}
- (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnumAttrWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value
                                 params:(MTRWriteParams * _Nullable)params
                      completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeEnumAttrWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeEnumAttrWithMinInterval:(NSNumber * _Nonnull)minInterval
                                      maxInterval:(NSNumber * _Nonnull)maxInterval
                                           params:(MTRSubscribeParams * _Nullable)params
                          subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                    reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeEnumAttrWithParams:subscribeParams
                       subscriptionEstablished:subscriptionEstablishedHandler
                                 reportHandler:reportHandler];
}
+ (void)readAttributeEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                       endpoint:(NSNumber *)endpoint
                                          queue:(dispatch_queue_t)queue
                              completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeEnumAttrWithAttributeCache:attributeCacheContainer
                                         endpoint:endpoint
                                            queue:queue
                                       completion:completionHandler];
}

- (void)readAttributeStructAttrWithCompletionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeStructAttrWithCompletion:completionHandler];
}
- (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull)value
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStructAttrWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeStructAttrWithValue:(MTRTestClusterClusterSimpleStruct * _Nonnull)value
                                   params:(MTRWriteParams * _Nullable)params
                        completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeStructAttrWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeStructAttrWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                        NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeStructAttrWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeStructAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                      NSError * _Nullable error))completionHandler
{
    [self readAttributeStructAttrWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRangeRestrictedInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRangeRestrictedInt8uWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8uWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8sWithCompletion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt8sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value
                                             params:(MTRWriteParams * _Nullable)params
                                  completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt8sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRangeRestrictedInt8sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRangeRestrictedInt8sWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt8sWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16uWithCompletion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt16uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt16uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRangeRestrictedInt16uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRangeRestrictedInt16uWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16uWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                    NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16sWithCompletion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt16sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value
                                              params:(MTRWriteParams * _Nullable)params
                                   completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeRangeRestrictedInt16sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeRangeRestrictedInt16sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                   maxInterval:(NSNumber * _Nonnull)maxInterval
                                                        params:(MTRSubscribeParams * _Nullable)params
                                       subscriptionEstablished:
                                           (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                 reportHandler:
                                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeRangeRestrictedInt16sWithParams:subscribeParams
                                    subscriptionEstablished:subscriptionEstablishedHandler
                                              reportHandler:reportHandler];
}
+ (void)readAttributeRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                    endpoint:(NSNumber *)endpoint
                                                       queue:(dispatch_queue_t)queue
                                           completionHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeRangeRestrictedInt16sWithAttributeCache:attributeCacheContainer
                                                      endpoint:endpoint
                                                         queue:queue
                                                    completion:completionHandler];
}

- (void)readAttributeListLongOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeListLongOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListLongOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListLongOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeListLongOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListLongOctetStringWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeListLongOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListLongOctetStringWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeListFabricScopedWithParams:(MTRReadParams * _Nullable)params
                              completionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListFabricScopedWithParams:params completion:completionHandler];
}
- (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListFabricScopedWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeListFabricScopedWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeListFabricScopedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeListFabricScopedWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeListFabricScopedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeListFabricScopedWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeTimedWriteBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                NSError * _Nullable error))completionHandler
{
    [self readAttributeTimedWriteBooleanWithCompletion:completionHandler];
}
- (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTimedWriteBooleanWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value
                                          params:(MTRWriteParams * _Nullable)params
                               completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeTimedWriteBooleanWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeTimedWriteBooleanWithMinInterval:(NSNumber * _Nonnull)minInterval
                                               maxInterval:(NSNumber * _Nonnull)maxInterval
                                                    params:(MTRSubscribeParams * _Nullable)params
                                   subscriptionEstablished:
                                       (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                             reportHandler:
                                                 (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeTimedWriteBooleanWithParams:subscribeParams
                                subscriptionEstablished:subscriptionEstablishedHandler
                                          reportHandler:reportHandler];
}
+ (void)readAttributeTimedWriteBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                endpoint:(NSNumber *)endpoint
                                                   queue:(dispatch_queue_t)queue
                                       completionHandler:
                                           (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeTimedWriteBooleanWithAttributeCache:attributeCacheContainer
                                                  endpoint:endpoint
                                                     queue:queue
                                                completion:completionHandler];
}

- (void)readAttributeGeneralErrorBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneralErrorBooleanWithCompletion:completionHandler];
}
- (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeGeneralErrorBooleanWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeGeneralErrorBooleanWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeGeneralErrorBooleanWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneralErrorBooleanWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeGeneralErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneralErrorBooleanWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeClusterErrorBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterErrorBooleanWithCompletion:completionHandler];
}
- (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeClusterErrorBooleanWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeClusterErrorBooleanWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeClusterErrorBooleanWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterErrorBooleanWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeClusterErrorBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterErrorBooleanWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeUnsupportedWithCompletionHandler:(void (^)(
                                                          NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnsupportedWithCompletion:completionHandler];
}
- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnsupportedWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value
                                    params:(MTRWriteParams * _Nullable)params
                         completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeUnsupportedWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeUnsupportedWithMinInterval:(NSNumber * _Nonnull)minInterval
                                         maxInterval:(NSNumber * _Nonnull)maxInterval
                                              params:(MTRSubscribeParams * _Nullable)params
                             subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                       reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeUnsupportedWithParams:subscribeParams
                          subscriptionEstablished:subscriptionEstablishedHandler
                                    reportHandler:reportHandler];
}
+ (void)readAttributeUnsupportedWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                          endpoint:(NSNumber *)endpoint
                                             queue:(dispatch_queue_t)queue
                                 completionHandler:
                                     (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeUnsupportedWithAttributeCache:attributeCacheContainer
                                            endpoint:endpoint
                                               queue:queue
                                          completion:completionHandler];
}

- (void)readAttributeNullableBooleanWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBooleanWithCompletion:completionHandler];
}
- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBooleanWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBooleanWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableBooleanWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableBooleanWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeNullableBooleanWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBooleanWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeNullableBitmap8WithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap8WithCompletion:completionHandler];
}
- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap8WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value
                                        params:(MTRWriteParams * _Nullable)params
                             completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap8WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableBitmap8WithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableBitmap8WithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeNullableBitmap8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap8WithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (void)readAttributeNullableBitmap16WithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap16WithCompletion:completionHandler];
}
- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap16WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap16WithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeNullableBitmap16WithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableBitmap16WithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeNullableBitmap16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap16WithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeNullableBitmap32WithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap32WithCompletion:completionHandler];
}
- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap32WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap32WithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeNullableBitmap32WithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableBitmap32WithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeNullableBitmap32WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap32WithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeNullableBitmap64WithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap64WithCompletion:completionHandler];
}
- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap64WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableBitmap64WithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeNullableBitmap64WithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableBitmap64WithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeNullableBitmap64WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableBitmap64WithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeNullableInt8uWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt8uWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8uWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeNullableInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt16uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt16uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt16uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt16uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt24uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt24uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt24uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt24uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt24uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt24uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt32uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt32uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt32uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt32uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt32uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt32uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt40uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt40uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt40uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt40uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt40uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt40uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt48uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt48uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt48uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt48uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt48uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt48uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt56uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt56uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt56uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt56uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt56uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt56uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt64uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt64uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt64uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt64uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt64uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt64uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt8sWithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt8sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt8sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt8sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt8sWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt8sWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeNullableInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt16sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt16sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt16sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt16sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt16sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt24sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt24sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt24sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt24sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt24sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt24sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt24sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt32sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt32sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt32sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt32sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt32sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt32sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt32sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt40sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt40sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt40sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt40sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt40sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt40sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt40sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt48sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt48sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt48sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt48sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt48sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt48sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt48sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt56sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt56sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt56sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt56sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt56sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt56sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt56sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableInt64sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt64sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableInt64sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableInt64sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableInt64sWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableInt64sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableInt64sWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableEnum8WithCompletionHandler:(void (^)(
                                                            NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum8WithCompletion:completionHandler];
}
- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnum8WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value
                                      params:(MTRWriteParams * _Nullable)params
                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnum8WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableEnum8WithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableEnum8WithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeNullableEnum8WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum8WithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeNullableEnum16WithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum16WithCompletion:completionHandler];
}
- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnum16WithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnum16WithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableEnum16WithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableEnum16WithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableEnum16WithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnum16WithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatSingleWithCompletion:completionHandler];
}
- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableFloatSingleWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableFloatSingleWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableFloatSingleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableFloatSingleWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeNullableFloatSingleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatSingleWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatDoubleWithCompletion:completionHandler];
}
- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableFloatDoubleWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableFloatDoubleWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableFloatDoubleWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableFloatDoubleWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeNullableFloatDoubleWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableFloatDoubleWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableOctetStringWithCompletion:completionHandler];
}
- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableOctetStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value
                                            params:(MTRWriteParams * _Nullable)params
                                 completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableOctetStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableOctetStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSData * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableOctetStringWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeNullableOctetStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableOctetStringWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeNullableCharStringWithCompletionHandler:(void (^)(NSString * _Nullable value,
                                                                 NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableCharStringWithCompletion:completionHandler];
}
- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableCharStringWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value
                                           params:(MTRWriteParams * _Nullable)params
                                completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableCharStringWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableCharStringWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                maxInterval:(NSNumber * _Nonnull)maxInterval
                                                     params:(MTRSubscribeParams * _Nullable)params
                                    subscriptionEstablished:
                                        (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                              reportHandler:
                                                  (void (^)(NSString * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableCharStringWithParams:subscribeParams
                                 subscriptionEstablished:subscriptionEstablishedHandler
                                           reportHandler:reportHandler];
}
+ (void)readAttributeNullableCharStringWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                 endpoint:(NSNumber *)endpoint
                                                    queue:(dispatch_queue_t)queue
                                        completionHandler:
                                            (void (^)(NSString * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableCharStringWithAttributeCache:attributeCacheContainer
                                                   endpoint:endpoint
                                                      queue:queue
                                                 completion:completionHandler];
}

- (void)readAttributeNullableEnumAttrWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                               NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnumAttrWithCompletion:completionHandler];
}
- (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnumAttrWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value
                                         params:(MTRWriteParams * _Nullable)params
                              completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableEnumAttrWithValue:value params:params completion:completionHandler];
}
- (void)
    subscribeAttributeNullableEnumAttrWithMinInterval:(NSNumber * _Nonnull)minInterval
                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                               params:(MTRSubscribeParams * _Nullable)params
                              subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                        reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableEnumAttrWithParams:subscribeParams
                               subscriptionEstablished:subscriptionEstablishedHandler
                                         reportHandler:reportHandler];
}
+ (void)readAttributeNullableEnumAttrWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                               endpoint:(NSNumber *)endpoint
                                                  queue:(dispatch_queue_t)queue
                                      completionHandler:
                                          (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableEnumAttrWithAttributeCache:attributeCacheContainer
                                                 endpoint:endpoint
                                                    queue:queue
                                               completion:completionHandler];
}

- (void)readAttributeNullableStructWithCompletionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableStructWithCompletion:completionHandler];
}
- (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable)value
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableStructWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableStructWithValue:(MTRTestClusterClusterSimpleStruct * _Nullable)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableStructWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableStructWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                            NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableStructWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeNullableStructWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:(void (^)(MTRTestClusterClusterSimpleStruct * _Nullable value,
                                                          NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableStructWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeNullableRangeRestrictedInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullable)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableRangeRestrictedInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableRangeRestrictedInt8uWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeNullableRangeRestrictedInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8uWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeNullableRangeRestrictedInt8sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt8sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullable)value
                                                     params:(MTRWriteParams * _Nullable)params
                                          completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt8sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableRangeRestrictedInt8sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                          maxInterval:(NSNumber * _Nonnull)maxInterval
                                                               params:(MTRSubscribeParams * _Nullable)params
                                              subscriptionEstablished:
                                                  (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                        reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                          NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableRangeRestrictedInt8sWithParams:subscribeParams
                                           subscriptionEstablished:subscriptionEstablishedHandler
                                                     reportHandler:reportHandler];
}
+ (void)readAttributeNullableRangeRestrictedInt8sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                           endpoint:(NSNumber *)endpoint
                                                              queue:(dispatch_queue_t)queue
                                                  completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                        NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt8sWithAttributeCache:attributeCacheContainer
                                                             endpoint:endpoint
                                                                queue:queue
                                                           completion:completionHandler];
}

- (void)readAttributeNullableRangeRestrictedInt16uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16uWithCompletion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt16uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt16uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableRangeRestrictedInt16uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableRangeRestrictedInt16uWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeNullableRangeRestrictedInt16uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16uWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeNullableRangeRestrictedInt16sWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                                            NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16sWithCompletion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt16sWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullable)value
                                                      params:(MTRWriteParams * _Nullable)params
                                           completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeNullableRangeRestrictedInt16sWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeNullableRangeRestrictedInt16sWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                                params:(MTRSubscribeParams * _Nullable)params
                                               subscriptionEstablished:
                                                   (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                         reportHandler:(void (^)(NSNumber * _Nullable value,
                                                                           NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeNullableRangeRestrictedInt16sWithParams:subscribeParams
                                            subscriptionEstablished:subscriptionEstablishedHandler
                                                      reportHandler:reportHandler];
}
+ (void)readAttributeNullableRangeRestrictedInt16sWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                            endpoint:(NSNumber *)endpoint
                                                               queue:(dispatch_queue_t)queue
                                                   completionHandler:(void (^)(NSNumber * _Nullable value,
                                                                         NSError * _Nullable error))completionHandler
{
    [self readAttributeNullableRangeRestrictedInt16sWithAttributeCache:attributeCacheContainer
                                                              endpoint:endpoint
                                                                 queue:queue
                                                            completion:completionHandler];
}

- (void)readAttributeWriteOnlyInt8uWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                             NSError * _Nullable error))completionHandler
{
    [self readAttributeWriteOnlyInt8uWithCompletion:completionHandler];
}
- (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWriteOnlyInt8uWithValue:value params:nil completion:completionHandler];
}
- (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value
                                       params:(MTRWriteParams * _Nullable)params
                            completionHandler:(MTRStatusCompletion)completionHandler
{
    [self writeAttributeWriteOnlyInt8uWithValue:value params:params completion:completionHandler];
}
- (void)subscribeAttributeWriteOnlyInt8uWithMinInterval:(NSNumber * _Nonnull)minInterval
                                            maxInterval:(NSNumber * _Nonnull)maxInterval
                                                 params:(MTRSubscribeParams * _Nullable)params
                                subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                          reportHandler:
                                              (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeWriteOnlyInt8uWithParams:subscribeParams
                             subscriptionEstablished:subscriptionEstablishedHandler
                                       reportHandler:reportHandler];
}
+ (void)readAttributeWriteOnlyInt8uWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                             endpoint:(NSNumber *)endpoint
                                                queue:(dispatch_queue_t)queue
                                    completionHandler:
                                        (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeWriteOnlyInt8uWithAttributeCache:attributeCacheContainer
                                               endpoint:endpoint
                                                  queue:queue
                                             completion:completionHandler];
}

- (void)readAttributeGeneratedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                   NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeGeneratedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                  maxInterval:(NSNumber * _Nonnull)maxInterval
                                                       params:(MTRSubscribeParams * _Nullable)params
                                      subscriptionEstablished:
                                          (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                                reportHandler:
                                                    (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeGeneratedCommandListWithParams:subscribeParams
                                   subscriptionEstablished:subscriptionEstablishedHandler
                                             reportHandler:reportHandler];
}
+ (void)readAttributeGeneratedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                   endpoint:(NSNumber *)endpoint
                                                      queue:(dispatch_queue_t)queue
                                          completionHandler:
                                              (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeGeneratedCommandListWithAttributeCache:attributeCacheContainer
                                                     endpoint:endpoint
                                                        queue:queue
                                                   completion:completionHandler];
}

- (void)readAttributeAcceptedCommandListWithCompletionHandler:(void (^)(NSArray * _Nullable value,
                                                                  NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAcceptedCommandListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                                 maxInterval:(NSNumber * _Nonnull)maxInterval
                                                      params:(MTRSubscribeParams * _Nullable)params
                                     subscriptionEstablished:
                                         (MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                               reportHandler:
                                                   (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAcceptedCommandListWithParams:subscribeParams
                                  subscriptionEstablished:subscriptionEstablishedHandler
                                            reportHandler:reportHandler];
}
+ (void)readAttributeAcceptedCommandListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                                  endpoint:(NSNumber *)endpoint
                                                     queue:(dispatch_queue_t)queue
                                         completionHandler:
                                             (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAcceptedCommandListWithAttributeCache:attributeCacheContainer
                                                    endpoint:endpoint
                                                       queue:queue
                                                  completion:completionHandler];
}

- (void)readAttributeAttributeListWithCompletionHandler:(void (^)(
                                                            NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithCompletion:completionHandler];
}
- (void)subscribeAttributeAttributeListWithMinInterval:(NSNumber * _Nonnull)minInterval
                                           maxInterval:(NSNumber * _Nonnull)maxInterval
                                                params:(MTRSubscribeParams * _Nullable)params
                               subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                         reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeAttributeListWithParams:subscribeParams
                            subscriptionEstablished:subscriptionEstablishedHandler
                                      reportHandler:reportHandler];
}
+ (void)readAttributeAttributeListWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                            endpoint:(NSNumber *)endpoint
                                               queue:(dispatch_queue_t)queue
                                   completionHandler:
                                       (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeAttributeListWithAttributeCache:attributeCacheContainer
                                              endpoint:endpoint
                                                 queue:queue
                                            completion:completionHandler];
}

- (void)readAttributeFeatureMapWithCompletionHandler:(void (^)(
                                                         NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithCompletion:completionHandler];
}
- (void)subscribeAttributeFeatureMapWithMinInterval:(NSNumber * _Nonnull)minInterval
                                        maxInterval:(NSNumber * _Nonnull)maxInterval
                                             params:(MTRSubscribeParams * _Nullable)params
                            subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                      reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeFeatureMapWithParams:subscribeParams
                         subscriptionEstablished:subscriptionEstablishedHandler
                                   reportHandler:reportHandler];
}
+ (void)readAttributeFeatureMapWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                         endpoint:(NSNumber *)endpoint
                                            queue:(dispatch_queue_t)queue
                                completionHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeFeatureMapWithAttributeCache:attributeCacheContainer
                                           endpoint:endpoint
                                              queue:queue
                                         completion:completionHandler];
}

- (void)readAttributeClusterRevisionWithCompletionHandler:(void (^)(NSNumber * _Nullable value,
                                                              NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithCompletion:completionHandler];
}
- (void)subscribeAttributeClusterRevisionWithMinInterval:(NSNumber * _Nonnull)minInterval
                                             maxInterval:(NSNumber * _Nonnull)maxInterval
                                                  params:(MTRSubscribeParams * _Nullable)params
                                 subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablishedHandler
                                           reportHandler:
                                               (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler
{
    MTRSubscribeParams * _Nullable subscribeParams = [params copy];
    if (subscribeParams == nil) {
        subscribeParams = [[MTRSubscribeParams alloc] initWithMinInterval:minInterval maxInterval:maxInterval];
    } else {
        subscribeParams.minInterval = minInterval;
        subscribeParams.maxInterval = maxInterval;
    }
    [self subscribeAttributeClusterRevisionWithParams:subscribeParams
                              subscriptionEstablished:subscriptionEstablishedHandler
                                        reportHandler:reportHandler];
}
+ (void)readAttributeClusterRevisionWithAttributeCache:(MTRAttributeCacheContainer *)attributeCacheContainer
                                              endpoint:(NSNumber *)endpoint
                                                 queue:(dispatch_queue_t)queue
                                     completionHandler:
                                         (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completionHandler
{
    [self readAttributeClusterRevisionWithAttributeCache:attributeCacheContainer
                                                endpoint:endpoint
                                                   queue:queue
                                              completion:completionHandler];
}

- (nullable instancetype)initWithDevice:(MTRBaseDevice *)device endpoint:(uint16_t)endpoint queue:(dispatch_queue_t)queue
{
    return [self initWithDevice:device endpointID:@(endpoint) queue:queue];
}

@end

// NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)